Xamarin

namespace SampleNamespace {
    class SampleClass {}

    interface SampleInterface {}

    struct SampleStruct {}

    enum SampleEnum {}

    delegate void SampleDelegate(int i);

    namespace SampleNamespace.Nested {
        class SampleClass2 {}
    }
}

using SampleNamespace;

class UseSampleClass {
    SampleClass sampleClass = new SampleClass();
}

public class ThrowTest
{

    static int GetNumber(int index)
    {
        int[] nums = { 300, 600, 900 };
        if (index > nums.Length)
        {
            throw new IndexOutOfRangeException();
        }
        return nums[index];

    }
    static void Main() 
    {
        int result = GetNumber(3);

    }
}
/*
    Output:
    The System.IndexOutOfRangeException exception occurs.
*/

#if DEBUG
    doSomethingOnlyInDebugMode();
#else
    doSomethingInReleaseMode();
#endif

[Conditional("DEBUG")]
private void doSomethingOnlyInDebugMode();

private void doSomethingInReleaseMode();

public ClassName() {
    doSomethingInReleaseMode();

    doSomethingOnlyInDebugMode();
}

using System;
public class AnyClass 
{
    [Obsolete("Don't use Old method, use New method", true)]
    static void Old( ) { }

    static void New( ) { }

    public static void Main( ) 
    {
        Old( );
    }
}

AnyClass.Old()' is obsolete: 'Don't use Old method,  use New method'

using System;

public class HelpAttribute : Attribute { }

[Help()]
public class SomeClass { }

[assembly: Help("this is a do-nothing assembly")]

public async Task<int> ExampleMethodAsyc() {
    // ...
}

var label = new Label();
label.SetBinding(Label.TextProperty, "Name");
label.BindingContext = new {Name = "John Doe", Company = "Xamarin"};

xlmns="http://xamarin.com/schemas/2014/forms"

xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"

xmlns:local="clr-namespace:XamlSamples;assembly=XamlSamples"
xmlns:sys="clr-namespace:System;assembly=mscorlib"

<Button Background="Blue" ... />

<Button>
  <Button.Background>
    "Blue"
  </Button.Background>
</Button>

<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="Phoneword.MainPage">
  <ContentPage.Padding>
    <OnPlatform x:TypeArguments="Thickness"
                iOS="20, 40, 20, 20"
                Android="20, 20, 20, 20"
                WinPhone="20, 20, 20, 20" />
  </ContentPage.Padding>
  <ContentPage.Content>
    <StackLayout VerticalOptions="FillAndExpand"
                 HorizontalOptions="FillAndExpand"
                 Orientation="Vertical"
                 Spacing="15">
      <Label Text="Enter a Phoneword:" />
      <Entry x:Name="phoneNumberText" Text="1-855-XAMARING" />
      <Button x:Name="translateButton" Text="Translate" Clicked="OnTranslate" />
      <Button x:Name="callButton" Text="Call" isEnabled="false" Clicked="OnCall" />
    </StackLayout>
  </ContentPage.Content>
</ContentPage>

using System;
using System.Threading.Tasks;

using Xamarin.Forms;

namespace Phoneword {
  public partial class MainPage : ContentPage{
      string translatedNumber;

      public MainPage() {
          InitializeComponent();
      }

          void OnTranslate(object sender, EventArgs e) {
              translatedNumber = Core.PhonewordTranslator.ToNumber (phoneNumberText.Text);

              if (!string.IsNullOrWhiteSpace (translatedNumber)) {
                  callButton.IsEnabled = true;
                  callButton.Text = "Call " + translatedNumber;
              }
              else {
                  callButton.IsEnabled = false;
                  callButton.Text = "Call";
              }
          }

          async void OnCall (object sender, EventArgs e) {
              if (await this.DisplayAlert ("Dial a Number", "Would you like to call " + translatedNumber + "?", "Yes", "No")) {
                  var dialer = DependencyService.Get<IDialer> ();

                  if (dialer != null) {
                      dialer.Dial(translatedNumber);
                  }
              }
          }
      }
  }       

<?xml version="1.0" encoding="UTF-8"?>
<ContentPage xmlns="http://xamarin.com/schemas/2014/forms" 
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml" 
             x:Class="MasterDetailPageNavigation.MasterPage">
    <ContentPage.Content>
        <StackLayout>
            <ListView x:Name="listView">
                <ListView.ItemTemplate>
                    <DataTemplate>
                        <ImageCell Text="{Binding Title}" ImageSource="{Binding IconSource}" />
                    </DataTemplate>
                </ListView.ItemTemplate>
            </ListView>
        </StackLayout>
    </ContentPage.Content>
</ContentPage>

// MasterPageItem.cs

using System;

namespace MasterDetailPageNavigation {
    public class MasterPageItem {
        public string Title { get; set; }

        public Type TargetType { get; set; }
    }
}

// MasterPage.xaml.cs

using System.Collections.Generic;
using Xamarin.Forms;

namespace MasterDetailPageNavigation {
    public partial class MasterPage : ContentPage {
        public ListView ListView {get { return listView; }}

        public MasterPage () {
            InitializeComponent();

            // First we instatiate and populate the list that will be our ItemsSource
            var masterPageItems = new List<MasterPageItem> ();
            masterPageItems.Add(new MasterPageItem {
                    Title = "Contacts",
                    TargeType = typeof(ContactsPage)
                });
            masterPageItems.Add(new MasterPageItem {
                    Title = "About"
                    TargetType = typeof(AboutPage)
                });

            // Set the ItemsSource of the ListView element, which we reference using listView
            listView.ItemsSource = masterPageItems;
        }
    }
}

<MasterDetailPage xmlns="http://xamarin.com/schemas/2014/forms"
                  xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
                  xmlns:local="clr-namespace:MasterDetailPageNavigation;assembly=MasterDetailPageNavigation"
                  x:Class="MasterDetailPageNavigation.MainPage">
    <MasterDetailPage.Master>
        <local:MasterPage x:Name="masterPage" />
    </MasterDetailPage.Master>
    <MasterDetailPage.Detail>
        <NavigationPage>
            <x:Arguments>
                <local:ContactsPage />
            </x:Arguments>
        </NavigationPage>
    </MasterDetailPage.Detail>
</MasterDetailPage>

public class MainPage : MasterDetailPage {
    public MainPage() {
        InitializeComponents();
    }
}

// Getting Keyed instances, and getting all the instances

// Default instance
var defaultInstance = SimpleIoc.Default.GetInstance<ConsumerWithInjection>();
// Keyed instances
var keyed1 = SimpleIoc.Default.GetInstance<ConsumerWithInjection>("key1");
var keyed2 = SimpleIoc.Default.GetInstance<ConsumerWithInjection>("key2");
var keyed3 = SimpleIoc.Default.GetInstance<ConsumerWithInjection>("key3");
// Get all the instances
var allInstances = SimpleIoc.Default.GeAllInstances<ConsumerWithInjection>();

// Registering the ServiceLocator

ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);

// Default instance
var defaultInstace = ServiceLocator.Current.GetInstance<ConsumerWithInjection>();
// Keyed instances
var keyed1 = ServiceLocator.Current.GetInstance<ConsumerWithInjection>("key1");
var keyed2 = ServiceLocator.Current.GetInstance<ConsumerWithInjection>("key2");
var keyed3 = ServiceLocator.Current.GetInstance<ConsumerWithInjection>("key3");
// Get all instances
var allInstances = ServiceLocator.Current.GetAllInstances<ConsumerWithInjection>();

public async void InitiateRegistriation() {
    // Registering at 0:00:00
    SimpleIoc.Default.Register(() => new DataItem(DateTime.Now()));
    await Task.Delay(5000);
    // Getting at 0:00:05
    var item = ServiceLocator.Current.GetInstance<DataItem>();
    away Task.Delay(5000);
    // Getting at 0:00:10. Creation time is still the same
    item = ServiceLocator.Current.GetInstance<DataItem>();
}

public class ViewModelLocator {
    static ViewModelLocator() {
        ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);

        if (ViewModelBase.IsInDesignModeStatic) {
            SimpleIoc.Default.Register<IRssService, Design.DesignRssService>();
        }
        else {
            SimpleIoc.Default.Register<IRssService, RssService>();
        }

        SimpleIoc.Default.Register<INavigationService, NavigationService>();
        SimpleIoc.Default.Register<MainViewModel>();
    }

    public MainViewModel Main {
        get {
            return ServiceLocator.Current.GetInstance<MainViewModel>();
        }
    }
}

public class MainViewModel : ViewModelBase {
    private readonly IRssService _rssService;
    private readonly INavigationService _navigationService;

    public ObservableCollection<RssItem> Items {
        get;
        private set;
    }

    public MainViewModel(IRssService rssService, INavigationService navigationService) {
        _rssService = rssService;
        _navigationService = navigationService;

        Items = new ObservableCollection<RssItem>();
    }
}