Redis Fundamentals for .NET Developers
Redis is an open source, in-memory data store used by millions of developers as a database, cache, streaming engine, and even a message broker.
In this live sessions, Stephen Lorello, Senior Field Engineer at Redis, joins us to show the the fundamental features .NET developers show know about using Redis
Today, we are shipping .NET 5.0 Release Candidate 1 (RC1). It is a near-final release of .NET 5.0, and the first of two RCs before the official release in November. RC1 is a “go live” release; you are supported using it in production.
MongoDB is a popular NoSQL database that makes it a great backend for Web APIs which lend themselves towards a document store rather than a relational store. In this blog we show how you can use MongoDB with ASP.NET Web API to build an ApiController with support for HTTP GET, PUT, POST, and DELETE.
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
// ...
services.AddTransient<ICustomerService, DefaultCustomerService>();
// ...
}
} public class SupportController
{
// DefaultCustomerService will be injected here:
public SupportController(ICustomerService customerService)
{
// ...
}
} namespace Microsoft.Extensions.DependencyInjection
{
public static class ServiceCollectionServiceExtensions
{
public static IServiceCollection AddScoped<TService>(
this IServiceCollection services) where TService : class;
public static IServiceCollection AddScoped(
this IServiceCollection services, Type serviceType, Type implementationType);
public static IServiceCollection AddScoped(
this IServiceCollection services, Type serviceType,
Func<IServiceProvider, object> implementationFactory);
public static IServiceCollection AddScoped<TService, TImplementation>(this IServiceCollection services)
public static IServiceCollection AddScoped(
this IServiceCollection services, Type serviceType);
public static IServiceCollection AddScoped<TService>(
this IServiceCollection services,
Func<IServiceProvider, TService> implementationFactory) where TService : class;
public static IServiceCollection AddScoped<TService, TImplementation>(
this IServiceCollection services,
Func<IServiceProvider, TImplementation> implementationFactory)
// ...
}
} namespace CoreIocServices
{
public interface IParameterizedService
{
string GetConstructorParameter();
}
public class ParameterizedService : IParameterizedService
{
private readonly string _connectionString;
public ParameterizedService(string connectionString)
{
_connectionString = connectionString;
}
public string GetConstructorParameter()
{
return _connectionString;
}
}
} services.AddTransient<IParameterizedService, ParameterizedService>();
services.AddTransient<IParameterizedService>(serviceProvider =>
{
return new ParameterizedService("some value ....");
}); services.AddTransient<IParameterizedService>(serviceProvider => new ParameterizedService("some value ....")); services.AddTransient<IParameterizedService>(serviceProvider =>
{
var config = serviceProvider.GetRequiredService<ITestService>().GetConfigValue();
return new ParameterizedService(config);
}); services.AddScoped<IUrlHelper>(serviceProvider =>
{
var actionContext = serviceProvider.GetRequiredService<IActionContextAccessor>().ActionContext;
var urlHelperFactory = serviceProvider.GetRequiredService<IUrlHelperFactory>();
return urlHelperFactory.GetUrlHelper(actionContext);
}); namespace Services
{
public class OrderHandler : IOrderHandler
{
private readonly IAccounting _accounting;
private readonly ISales _sales;
public OrderHandler(IAccounting accounting, ISales sales)
{ public class OrderHandlerLazy : IOrderHandler
{
public OrderHandlerLazy(Lazy<IAccounting> accounting, Lazy<ISales> sales)
{ services.AddTransient<IOrderHandler, OrderHandlerLazy>();
services.AddTransient<IAccounting, Accounting>()
.AddTransient(serviceProvider => new Lazy<IAccounting>(() => serviceProvider.GetRequiredService<IAccounting>()));
services.AddTransient<ISales, Sales>()
.AddTransient(serviceProvider => new Lazy<ISales>(() => serviceProvider.GetRequiredService<ISales>())); services.AddTransient<IMyDisposableService, MyDisposableService>();
public class AnotherController
{
public AnotherController(MyDisposableService customerService)
{
// ...
}
} An unhandled exception occurred while processing the request. InvalidOperationException: Unable to resolve service for type ‘MyDisposableService’ while attempting to activate ‘AnotherController’. Microsoft.Extensions.DependencyInjection.ActivatorUtilities.GetService(IServiceProvider sp, Type type, Type requiredBy, bool isDefaultParameterRequired)
services.AddTransient<IMyDisposableService, MyDisposableService>(); services.AddTransient<MyDisposableService>(serviceProvider => serviceProvider.GetRequiredService<IMyDisposableService>() as MyDisposableService);
There’s a lot you can do on GitHub that doesn’t require a complex development environment, like sharing feedback on a design discussion or reviewing a few lines of code. We’re making these tasks easier to complete while you’re on the go, with a fully-native experience. With GitHub for mobile, you have the flexibility to move work forward and stay in touch with your team, wherever you are
public class PooledObject
{
DateTime _createdAt = DateTime.Now;
public DateTime CreatedAt
{
get { return _createdAt; }
}
public string TempData { get; set; }
public void DoSomething(string name)
{
Console.WriteLine($"{name} : {TempData} is written on {CreatedAt}");
}
} public static class Pool
{
private static List<PooledObject> _available = new List<PooledObject>();
private static List<PooledObject> _inUse = new List<PooledObject>();
public static PooledObject GetObject()
{
lock(_available)
{
if (_available.Count != 0)
{
PooledObject po = _available[0];
_inUse.Add(po);
_available.RemoveAt(0);
return po;
}
else
{
PooledObject po = new PooledObject();
_inUse.Add(po);
return po;
}
}
}
public static void ReleaseObject(PooledObject po)
{
CleanUp(po);
lock (_available)
{
_available.Add(po);
_inUse.Remove(po);
}
}
private static void CleanUp(PooledObject po)
{
po.TempData = null;
}
} var obj1 = Pool.GetObject();
obj1.DoSomething("obj1");
Thread.Sleep(2000);
var obj2 = Pool.GetObject();
obj2.DoSomething("obj2");
Pool.ReleaseObject(obj1);
Thread.Sleep(2000);
var obj3 = Pool.GetObject();
obj3.DoSomething("obj3"); obj1 : is written on 4/21/2016 11:25:26 AM obj2 : is written on 4/21/2016 11:25:28 AM obj3 : is written on 4/21/2016 11:25:26 AM
Before (Automatic inverse example):
<TextBox Text = "{Binding Path=A, Conveter={x:StaticResource MyMathConverter}">
public class MyMathConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
var source = (int)value;
return Math.Sin(source*2)-5;
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
var res = Double.Parse(value);
return (int)(Math.Asin(res + 5) / 2);
}
}
After:
<TextBox Text = "{c:Binding 'Math.Sin(A*2)-5'}"> 