System.Reflection.Assembly thisExe = System.Reflection.Assembly.GetExecutingAssembly();
System.IO.Stream file = 
    thisExe.GetManifestResourceStream("ZedGraph.Demo.ngc4414.jpg");

// If the resource is not present it will be null or empty
if (null != file) {
    Image image = Image.FromStream(file);
}

public class MyBaseClass
{
    private int _myProperty;

    public MyBaseClass(int value)
    {
        _myProperty = value;
    }

    public int MyProperty
    {
        get { return _myProperty; }
        set { _myProperty = value; }
    }
}

public class MyDerivedClass : MyBaseClass
{
    public MyDerivedClass(int value) : base(value)
    {
        // additional initialization logic for MyDerivedClass
    }
}
//To create an instance of MyDerivedClass and set its MyProperty value using the constructor, you can use the following code:
var obj = new MyDerivedClass(42);
Console.WriteLine(obj.MyProperty); // prints 42

using Unity.Collections;
using Unity.Entities;

public partial struct NameSystem : ISystem
{
    public void OnCreate(ref SystemState state)
    {
        // throw new System.NotImplementedException();
    }

    public void OnUpdate(ref SystemState state)
    {
        // throw new System.NotImplementedException();
    }

    public void OnDestroy(ref SystemState state)
    {
        // throw new System.NotImplementedException();
    }


}

int i = 0;
do 
{
  Console.WriteLine(i);
  i++;
}
while (i < 5);

EventTrigger trigger = obj.GetComponent<EventTrigger>();
EventTrigger.Entry entry = new EventTrigger.Entry();
entry.eventID = EventTriggerType.PointerEnter;
entry.callback.AddListener((eventData) =>
{
  //do something
});
trigger.triggers.Add(entry);

MySqlConnector
Microsoft.EntityFrameworkCore

private void PrintDocument1_PrintPage(System.Object sender, System.Drawing.Printing.PrintPageEventArgs e)
{
    byte[] gambar = new byte[0];
    gambar = (byte[])(dgv_ProductData.CurrentRow.Cells[5].Value);
    MemoryStream ms = new MemoryStream(gambar);
    Bitmap bm = new Bitmap(ms);
    e.Graphics.DrawImage(bm, 0, 0);
}

private void btn_Print_Click(object sender, EventArgs e)
{
    printPreviewDialog1.Document = printDocument1;
    printPreviewDialog1.ShowDialog();
    printDialog1.ShowDialog();
}

switch(expression) 
{
  case x:
    // code block
    break;
  case y:
    // code block
    break;
  default:
    // code block
    break;
}

void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
{            
    if (dataGridView1.Columns[e.ColumnIndex].Name == "Imagen")
    {
        e.Value = Image.FromFile("Foto.jpg");
    }
}

if (dataGridView1.Rows.Count > 0)
           dataGridView1.Rows[dataGridView1.Rows.Count-1].DefaultCellStyle.BackColor = Color.Red;

<!-- Button trigger modal -->
<button type="button" class="btn btn-primary" data-toggle="modal" data-target="#exampleModalCenter">
  Launch demo modal
</button>

<!-- Modal -->
<div class="modal fade" id="exampleModalCenter" tabindex="-1" role="dialog" aria-labelledby="exampleModalCenterTitle" aria-hidden="true">
  <div class="modal-dialog modal-dialog-centered" role="document">
    <div class="modal-content">
      <div class="modal-header">
        <h5 class="modal-title" id="exampleModalLongTitle">Modal title</h5>
        <button type="button" class="close" data-dismiss="modal" aria-label="Close">
          <span aria-hidden="true">×</span>
        </button>
      </div>
      <div class="modal-body">
        ...
      </div>
      <div class="modal-footer">
        <button type="button" class="btn btn-secondary" data-dismiss="modal">Close</button>
        <button type="button" class="btn btn-primary">Save changes</button>
      </div>
    </div>
  </div>
</div>

Process p = null; 
try 
{
  // Start the process 
  p = System.Diagnostics.Process.Start(this.exeName); 

  // Wait for process to be created and enter idle condition 
  p.WaitForInputIdle(); 

  // Get the main handle
  appWin = p.MainWindowHandle; 
} 
catch (Exception ex) 
{ 
  MessageBox.Show(this, ex.Message, "Error"); 
}

public ChromiumWebBrowser browser;
public void InitBrowser(){
    Cef.Initialize(new CefSettings());
    browser = new ChromiumWebBrowser ("www.google.com");
    this.Controls.Add(browser);
    browser.Dock = DockStyle.Fill;
}

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddProblemDetails(setup =>
        {
            setup.IncludeExceptionDetails = _ => !Environment.IsDevelopment();
            setup.Map<OutOfCreditException>(exception => new OutOfCreditProblemDetails
            {
                Title = exception.Message,
                Detail = exception.Description,
                Balance = exception.Balance,
                Status = StatusCodes.Status403Forbidden,
                Type = exception.Type
            });
        })

    ...

}

using Ardalis.GuardClauses;
using System;
using Xunit;

namespace UnitTests.GuardClauses
{
    public class InvalidEmailGuard
    {
        [Fact]
        public void ThrowsArgumentNullExceptionIfNullOrEmptyEmail()
        {
            string? email = null;
            Assert.Throws<ArgumentNullException>(() => Guard.Against.InvalidEmail(email, nameof(email)));
        }

        [Fact]
        public void ThrowsArgumentExceptionIfEmailDoesNotEndInCorrectSuffix()
        {
            var email = "eric@fleming.invalidsuffix";
            Assert.Throws<ArgumentException>(() => Guard.Against.InvalidEmail(email, nameof(email)));
        }

        [Fact]
        public void ReturnsEmailAddressGivenValidEmail()
        {
            var validEmailAddress = "eric@fleming.com";
            var result = Guard.Against.InvalidEmail(validEmailAddress, nameof(validEmailAddress));

            Assert.Equal(validEmailAddress, result);
        }
    }
}

public class Invitee
{
    public string Email { get; private set; }
    public string? FirstName { get; private set; }
    public string? LastName { get; private set; }

    public Invitee(string email, string? firstName, string? lastName)
    {
        Email = Guard.Against.InvalidEmail(email, nameof(Email));
        FirstName = firstName;
        LastName = lastName;
    }
}

namespace Ardalis.GuardClauses
{
    public static class InvalidEmailGuard
    {
        public static string InvalidEmail(this IGuardClause guardClause, string email, string parameterName)
        {
            Guard.Against.NullOrEmpty(email, nameof(email));

            var emailSuffix = ".com";

            if (!email.EndsWith(emailSuffix))
            {
                throw new ArgumentException($"Invalid Email - must end in {emailSuffix}", parameterName);
            }

            return email;
        }
    }
}

public class TestService
{
    private IService1 Service1;
    private IService2 Service2;

    public TestService(IService1 service1, IService2 service2)
    {
        Service1 = Guard.Against.Null(service1, nameof(service1));
        Service2 = Guard.Against.Null(service2, nameof(service2));
    }
}

public class Invitee
{
    public string Email { get; private set; }
    public string? FirstName { get; private set; }
    public string? LastName { get; private set; }

    public Invitee(string email, string? firstName, string? lastName)
    {
        Email = Guard.Against.NullOrEmpty(email, nameof(Email));
        FirstName = firstName;
        LastName = lastName;
    }
}

public class Invitee
{
    public string Email { get; private set; }
    public string? FirstName { get; private set; }
    public string? LastName { get; private set; }

    public Invitee(string email, string? firstName, string? lastName)
    {
        Email = email;
        FirstName = firstName;
        LastName = lastName;
    }
}

var map = new GMap2(document.getElementById('map_canvas'));

using System.Threading;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Northwind.Application.Common.Interfaces;
using Northwind.Common;
using Northwind.Domain.Entities;
using Northwind.Domain.Common;

namespace Northwind.Persistence
{
    public class NorthwindDbContext : DbContext, INorthwindDbContext
    {
        private readonly ICurrentUserService _currentUserService;
        private readonly IDateTime _dateTime;

        public NorthwindDbContext(DbContextOptions<NorthwindDbContext> options)
            : base(options)
        {
        }

        public NorthwindDbContext(
            DbContextOptions<NorthwindDbContext> options, 
            ICurrentUserService currentUserService,
            IDateTime dateTime)
            : base(options)
        {
            _currentUserService = currentUserService;
            _dateTime = dateTime;
        }

        public DbSet<Category> Categories { get; set; }

        public DbSet<Customer> Customers { get; set; }

        public DbSet<Employee> Employees { get; set; }

        public DbSet<EmployeeTerritory> EmployeeTerritories { get; set; }

        public DbSet<OrderDetail> OrderDetails { get; set; }

        public DbSet<Order> Orders { get; set; }

        public DbSet<Product> Products { get; set; }

        public DbSet<Region> Region { get; set; }

        public DbSet<Shipper> Shippers { get; set; }

        public DbSet<Supplier> Suppliers { get; set; }

        public DbSet<Territory> Territories { get; set; }

        public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken())
        {
            foreach (var entry in ChangeTracker.Entries<AuditableEntity>())
            {
                switch (entry.State)
                {
                    case EntityState.Added:
                        entry.Entity.CreatedBy = _currentUserService.UserId;
                        entry.Entity.Created = _dateTime.Now;
                        break;
                    case EntityState.Modified:
                        entry.Entity.LastModifiedBy = _currentUserService.UserId;
                        entry.Entity.LastModified = _dateTime.Now;
                        break;
                }
            }

            return base.SaveChangesAsync(cancellationToken);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.ApplyConfigurationsFromAssembly(typeof(NorthwindDbContext).Assembly);
        }
    }
}

private void RegisteredServicesPage(IApplicationBuilder app)
        {
            app.Map("/services", builder => builder.Run(async context =>
            {
                var sb = new StringBuilder();
                sb.Append("<h1>Registered Services</h1>");
                sb.Append("<table><thead>");
                sb.Append("<tr><th>Type</th><th>Lifetime</th><th>Instance</th></tr>");
                sb.Append("</thead><tbody>");
                foreach (var svc in _services)
                {
                    sb.Append("<tr>");
                    sb.Append($"<td>{svc.ServiceType.FullName}</td>");
                    sb.Append($"<td>{svc.Lifetime}</td>");
                    sb.Append($"<td>{svc.ImplementationType?.FullName}</td>");
                    sb.Append("</tr>");
                }
                sb.Append("</tbody></table>");
                await context.Response.WriteAsync(sb.ToString());
            }));
        }

public class CustomerValidator : AbstractValidator<CustomerModel>
{
    public CustomerValidator()
    {
        RuleFor(x => x.Name).NotNull().NotEmpty();
        RuleFor(x => x.Name).Length(20, 250);
        RuleFor(x => x.PhoneNumber).NotEmpty().WithMessage("Please specify a phone number.");
        RuleFor(x => x.Age).InclusiveBetween(18, 60);

        // Complex Properties
        RuleFor(x => x.Address).InjectValidator();
        
        // Other way
        //RuleFor(x => x.Address).SetValidator(new AddressValidator());

        // Collections of Complex Types
        //RuleForEach(x => x.Addresses).SetValidator(new AddressValidator());
    }
}


// Address Validator
public class AddressValidator : AbstractValidator<AddressModel>
{
    public AddressValidator()
    {
        RuleFor(x => x.State).NotNull().NotEmpty();
        RuleFor(x => x.Country).NotEmpty().WithMessage("Please specify a Country.");

        RuleFor(x => x.Postcode).NotNull();
        RuleFor(x => x.Postcode).Must(BeAValidPostcode).WithMessage("Please specify a valid postcode");
    }

    private bool BeAValidPostcode(string postcode)
    {
        // custom postcode validating logic goes here.

        return true;
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddProblemDetails(setup =>
        {
            setup.IncludeExceptionDetails = _ => !Environment.IsDevelopment();
            setup.Map<OutOfCreditException>(exception => new OutOfCreditProblemDetails
            {
                Title = exception.Message,
                Detail = exception.Description,
                Balance = exception.Balance,
                Status = StatusCodes.Status403Forbidden,
                Type = exception.Type
            });
        })

    ...

}

internal class OutOfCreditProblemDetails : ProblemDetails
{
    public decimal Balance { get; set; }
}

[HttpPost]
public ActionResult Transfer(TransferInfo model)
{
    throw new OutOfCreditException(
        "You do not have enough credit.",
        balance: 30,
        cost: 50);

    return Ok();
}

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddProblemDetails(setup =>
        {
            setup.IncludeExceptionDetails = _ => Environment.IsDevelopment();
        })

    ...
}

public void ConfigureServices(IServiceCollection services)
{
    services
        .AddMvc()
        .SetCompatibilityVersion(CompatibilityVersion.Version_2_2);

    services.Configure<ApiBehaviorOptions>(options =>
    {
        options.InvalidModelStateResponseFactory = context =>
        {
            var problemDetails = new ValidationProblemDetails(context.ModelState)
            {
                Instance = context.HttpContext.Request.Path,
                Status = StatusCodes.Status400BadRequest,
                Type = $"https://httpstatuses.com/400",
                Detail = ApiConstants.Messages.ModelStateValidation
            };
            return new BadRequestObjectResult(problemDetails)
            {
                ContentTypes =
                {
                    ApiConstants.ContentTypes.ProblemJson,
                    ApiConstants.ContentTypes.ProblemXml
                }
            };
        };
    });
}

[HttpPost]
public ActionResult Transfer(TransferInfo model)
{
    if (!ModelState.IsValid)
    {
        var problemDetails = new ValidationProblemDetails(ModelState);

        return new ObjectResult(problemDetails)
        {
            ContentTypes = { "application/problem+json" },
            StatusCode = 403,
        };
    }

    return Ok();
}

[HttpPost]
public ActionResult Transfer()
{
    try
    {
        /// Make a transfer
    }
    catch (OutOfCreditException ex)
    {
        var problemDetails = new ProblemDetails
        {
            Status = StatusCodes.Status403Forbidden,
            Type = "https://example.com/probs/out-of-credit",
            Title = "You do not have enough credit.",
            Detail = "Your current balance is 30, but that costs 50.",
            Instance = HttpContext.Request.Path
        };

        return new ObjectResult(problemDetails)
        {
            ContentTypes = { "application/problem+json" },
            StatusCode = 403,
        };
    }

    return Ok();
}

namespace FetchAppsettingsValue.Controllers
{
    using Microsoft.AspNetCore.Mvc;
    using Microsoft.Extensions.Options;
    using System.Collections.Generic;

    [Route("api/Option")]
    [ApiController]
    public class OptionController : ControllerBase
    {
        private readonly IOptions<Logging> _logging;
        public OptionController(IOptions<Logging> logging)
        {
            _logging = logging;
        }

        // GET: api/Option
        [HttpGet]
        public IEnumerable<string> Get()
        {
            var result = _logging.Value.LogLevel.Default; // "Information"

            return new string[] { result };
        }
    }
}

namespace FetchAppsettingsValue.Controllers
{
    using Microsoft.AspNetCore.Mvc;
    using Microsoft.Extensions.Options;
    using System.Collections.Generic;

    [Route("api/Option")]
    [ApiController]
    public class OptionController : ControllerBase
    {
        private readonly IOptions<Logging> _logging;
        public OptionController(IOptions<Logging> logging)
        {
            _logging = logging;
        }

        // GET: api/Option
        [HttpGet]
        public IEnumerable<string> Get()
        {
            var result = _logging.Value.LogLevel.Default; // "Information"

            return new string[] { result };
        }
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<Logging>(Configuration.GetSection("Logging"));

    services.AddControllers();
}

//AppSettings.cs
namespace FetchAppsettingsValue
{
    public class AppSettings
    {
        public Logging Logging { get; set; }
        public string AllowedHosts { get; set; }
    }

    public class Logging
    {
        public LogLevel LogLevel { get; set; }
    }

    public class LogLevel
    {
        public string Default { get; set; }

        public string Warning { get; set; }

        public string Error { get; set; }
    }
}

namespace FetchAppsettingsValue.Controllers
{
    using Microsoft.AspNetCore.Mvc;
    using Microsoft.Extensions.Configuration;
    using System.Collections.Generic;

    [Route("api/Configuration")]
    [ApiController]
    public class ConfigurationController : ControllerBase
    {
        private readonly IConfiguration _config;

        public ConfigurationController(IConfiguration config)
        {
            _config = config;
        }

        // GET: api/Configuration
        [HttpGet]
        public IEnumerable<string> Get()
        {
            var result = _config.GetValue<string>("Logging:LogLevel:Default"); // "Information"
            return new string[] { result.ToString() };
        }
    }
}

using System;
class RemoveCharacter {
  static void Main() {
    string s = "king";
    string result = s.Remove(s.Length-1);
    Console.WriteLine(result);
  }
}

using ConsumingWebAapiRESTinMVC.Models;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web.Mvc;

namespace ConsumingWebAapiRESTinMVC.Controllers
{
    public class HomeController : Controller
    {
        //Hosted web API REST Service base url
        string Baseurl = "http://192.168.95.1:5555/";
        public async Task<ActionResult> Index()
        {
            List<Employee> EmpInfo = new List<Employee>();
            using (var client = new HttpClient())
            {
                //Passing service base url
                client.BaseAddress = new Uri(Baseurl);
                client.DefaultRequestHeaders.Clear();
                //Define request data format
                client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                //Sending request to find web api REST service resource GetAllEmployees using HttpClient
                HttpResponseMessage Res = await client.GetAsync("api/Employee/GetAllEmployees");
                //Checking the response is successful or not which is sent using HttpClient
                if (Res.IsSuccessStatusCode)
                {
                    //Storing the response details recieved from web api
                    var EmpResponse = Res.Content.ReadAsStringAsync().Result;
                    //Deserializing the response recieved from web api and storing into the Employee list
                    EmpInfo = JsonConvert.DeserializeObject<List<Employee>>(EmpResponse);
                }
                //returning the employee list to view
                return View(EmpInfo);
            }
        }
    }
}

RaycastHit hit;
Ray ray = camera.ScreenPointToRay(Input.mousePosition);

if (Physics.Raycast(ray, out hit)) {
  Transform objectHit = hit.transform;

  // Do something with the object that was hit by the raycast.
}

using System;
using System.Diagnostics.CodeAnalysis;

public class Clock : IEquatable<Clock>
{
    private int _hour;
    private int _minute;

    public Clock(int hours, int minutes)
    {
        _hour = (hours                                    // just take the given hours and
            + minutes / 60                                // add full hours of minutes if we have more than 60
                                                          // minutes
            - (minutes < 0 && minutes % 60 != 0 ? 1 : 0)  // but the part of negative minutes that is not an full
                                                          // hour subtracts one hour, e.g. 01:-10 means (00:50)
            ) % 24;                                       // at last, ensure hours roll over when longer as a day

        if (_hour < 0) _hour += 24;      // finally avoid negative hours: e.g. -3 means 21 (3 hours befor midnight)

        _minute = minutes % 60;          // just take the minutes, but to ensure they roll over when longer as an
                                         // hour, contribution to the hour was already added above
        if (_minute < 0) _minute += 60;  // e.g. -10 means 50 (10 minutes befor the next full hour)
    }

    public Clock Add(int minutesToAdd) => new Clock(_hour, _minute + minutesToAdd);

    public Clock Subtract(int minutesToSubtract) => new Clock(_hour, _minute - minutesToSubtract);

    public override string ToString() => $"{_hour:00}:{_minute:00}";

    public bool Equals([AllowNull] Clock other)
    {
        if (other == null)
            return false;
        if (this == other)
            return true;
        return _hour == other._hour && _minute == other._minute;
    }

    // these methods are not needed to make the tests running but it is recommended to override Equals(object) and
    // GetHashCode() when implementing IEquatable
    public override bool Equals(object obj) => Equals(obj as Clock);
    public override int GetHashCode() => _hour * 60 + _minute;
}

using System;
using System.Linq;

/*Luhn validates and creates checksum codes*/
public class Luhn {
	private int[] Code;

	/*Luhn creates a new checksum number*/
	public Luhn(long code) {
		Code = code.ToString ()
			.ToArray()
			.Select (d => (int)(d - '0'))
			.ToArray();
	}

	/*CheckDigit returns the last number*/
	public int CheckDigit {
		get { return Code.Last(); }
	}

	/*Addends doubles every other number starting from the right
	and subtracts 9 if the result is 10 or greater*/
	public int[] Addends {
		get {
			int[] doubled = (int[])Code.Clone();
			for (int i = doubled.Length - 2; 0 <= i; i -= 2) {
				doubled [i] *= 2;
				if (10 <= doubled [i])
					doubled[i] -= 9;
			}
			return doubled;
		}
	}

	/*Checksum sums all the digits after adding the ends*/
	public int Checksum {
		get { return Addends
				.Aggregate (0, (total, n) => total + n);
			}
	}

	/*Valid is true when the code is valid*/
	public bool Valid {
		get { return (Checksum % 10) == 0; }
	}

	/*Create adds a check digit to make the code valid*/
	public static long Create(long code) {
		code *= 10;
		Luhn luhn = new Luhn (code);
		if (luhn.Valid)
			return code;
		return code + (10 - (luhn.Checksum % 10));
	}
}