How to use Microsoft.Maui.Essentials? - maui

How can I setup Microsoft.Maui.Essentials in my MAUI app? I read that it comes by default with .NET 6 which I have installed but whenever I use the Microsoft.Maui.Essentials; an error message appears:
The type or namespace name 'Essentials' does not exist in the namespace 'Microsoft.Maui' (are you missing an assembly reference
Your help is appreciated.

Essentials as a name(space) has gone away at some point. All the APIs are now devided in more logical namespaces. You can see the PR for that here. But let me add the list of APIs and their new namespaces here as well:
namespace Microsoft.Maui.Accessibility {
public interface ISemanticScreenReader {}
public static class SemanticScreenReader {}
}
namespace Microsoft.Maui.ApplicationModel {
public enum ActivityState {}
public class ActivityStateChangedEventArgs : EventArgs {}
public class AppAction {}
public class AppActionEventArgs : EventArgs {}
public static class AppActions {}
public static class AppInfo {}
public enum AppPackagingModel {}
public enum AppTheme {}
public static class Browser {}
public enum BrowserLaunchFlags {}
public enum BrowserLaunchMode {}
public class BrowserLaunchOptions {}
public enum BrowserTitleMode {}
public class FeatureNotEnabledException : InvalidOperationException {}
public class FeatureNotSupportedException : NotSupportedException {}
public interface IAppActions {}
public interface IAppInfo {}
public interface IBrowser {}
public interface ILauncher {}
public interface IMap {}
public interface IVersionTracking {}
public static class Launcher {}
public enum LayoutDirection {}
public static class MainThread {}
public static class Map {}
public class MapLaunchOptions {}
public enum NavigationMode {}
public class OpenFileRequest {}
public class PermissionException : UnauthorizedAccessException {}
public static class Permissions {}
public enum PermissionStatus {}
public static class Platform {}
public static class VersionTracking {}
}
namespace Microsoft.Maui.ApplicationModel.Communication {
public class Contact {}
public class ContactEmail {}
public class ContactPhone {}
public static class Contacts {}
public static class Email {}
public class EmailAttachment : FileBase {}
public enum EmailBodyFormat {}
public class EmailMessage {}
public interface IContacts {}
public interface IEmail {}
public interface IPhoneDialer {}
public interface ISms {}
public static class PhoneDialer {}
public static class Sms {}
public class SmsMessage {}
}
namespace Microsoft.Maui.ApplicationModel.DataTransfer {
public static class Clipboard {}
public interface IClipboard {}
public interface IShare {}
public static class Share {}
public class ShareFile : FileBase {}
public class ShareFileRequest : ShareRequestBase {}
public class ShareMultipleFilesRequest : ShareRequestBase {}
public abstract class ShareRequestBase {}
public class ShareTextRequest : ShareRequestBase {}
}
namespace Microsoft.Maui.Authentication {
public static class AppleSignInAuthenticator {}
public interface IAppleSignInAuthenticator {}
public interface IPlatformWebAuthenticatorCallback {}
public interface IWebAuthenticator {}
public static class WebAuthenticator {}
public abstract class WebAuthenticatorCallbackActivity : Activity {}
public class WebAuthenticatorOptions {}
public class WebAuthenticatorResult {}
}
namespace Microsoft.Maui.Devices {
public static class Battery {}
public class BatteryInfoChangedEventArgs : EventArgs {}
public enum BatteryPowerSource {}
public enum BatteryState {}
public static class DeviceDisplay {}
public readonly struct DeviceIdiom : IEquatable<DeviceIdiom> {}
public static class DeviceInfo {}
public readonly struct DevicePlatform : IEquatable<DevicePlatform> {}
public enum DeviceType {}
public readonly struct DisplayInfo : IEquatable<DisplayInfo> {}
public class DisplayInfoChangedEventArgs : EventArgs {}
public enum DisplayOrientation {}
public enum DisplayRotation {}
public enum EnergySaverStatus {}
public class EnergySaverStatusChangedEventArgs : EventArgs {}
public static class Flashlight {}
public static class HapticFeedback {}
public enum HapticFeedbackType {}
public interface IBattery {}
public interface IDeviceDisplay {}
public interface IDeviceInfo {}
public interface IFlashlight {}
public interface IHapticFeedback {}
public interface IVibration {}
public static class Vibration {}
}
namespace Microsoft.Maui.Devices.Sensors {
public static class Accelerometer {}
public class AccelerometerChangedEventArgs : EventArgs {}
public readonly struct AccelerometerData : IEquatable<AccelerometerData> {}
public enum AltitudeReferenceSystem {}
public static class Barometer {}
public class BarometerChangedEventArgs : EventArgs {}
public readonly struct BarometerData : IEquatable<BarometerData> {}
public static class Compass {}
public class CompassChangedEventArgs : EventArgs {}
public readonly struct CompassData : IEquatable<CompassData> {}
public enum DistanceUnits {}
public static class Geocoding {}
public static class Geolocation {}
public enum GeolocationAccuracy {}
public class GeolocationRequest {}
public static class Gyroscope {}
public class GyroscopeChangedEventArgs : EventArgs {}
public readonly struct GyroscopeData : IEquatable<GyroscopeData> {}
public interface IAccelerometer {}
public interface IBarometer {}
public interface ICompass {}
public interface IGeocoding {}
public interface IGeolocation {}
public interface IGyroscope {}
public interface IMagnetometer {}
public interface IOrientationSensor {}
public interface IPlatformCompass {}
public class Location {}
public static class LocationExtensions {}
public static class Magnetometer {}
public class MagnetometerChangedEventArgs : EventArgs {}
public readonly struct MagnetometerData : IEquatable<MagnetometerData> {}
public static class OrientationSensor {}
public class OrientationSensorChangedEventArgs : EventArgs {}
public readonly struct OrientationSensorData : IEquatable<OrientationSensorData> {}
public class Placemark {}
public static class PlacemarkExtensions {}
public enum SensorSpeed {}
}
namespace Microsoft.Maui.Media {
public interface IMediaPicker {}
public interface IScreenshot {}
public interface IScreenshotResult {}
public interface ITextToSpeech {}
public class Locale {}
public static class MediaPicker {}
public class MediaPickerOptions {}
public static class Screenshot {}
public static class ScreenshotExtensions {}
public enum ScreenshotFormat {}
public class SpeechOptions {}
public static class TextToSpeech {}
public static class UnitConverters {}
}
namespace Microsoft.Maui.Networking {
public enum ConnectionProfile {}
public static class Connectivity {}
public class ConnectivityChangedEventArgs : EventArgs {}
public interface IConnectivity {}
public enum NetworkAccess {}
}
namespace Microsoft.Maui.Storage {
public abstract class FileBase {}
public static class FilePicker {}
public class FilePickerFileType {}
public class FileProvider : FileProvider {}
public enum FileProviderLocation {}
public class FileResult : FileBase {}
public static class FileSystem {}
public interface IFileSystem {}
public interface IPlatformFileSystem {}
public interface IPlatformSecureStorage {}
public interface IPreferences {}
public interface ISecureStorage {}
public class PickOptions {}
public static class Preferences {}
public class ReadOnlyFile : FileBase {}
public static class SecureStorage {}
}

Related

Unity: How To Serialize A Class Inside Struct

public class TopClass
{
[System.Serializable]
public struct WantToBeVisibleInInspector
{
public SomeEnum appearsInInspector;
public SomeClass doesNOTAppearInInspector;
}
[SerializeField] private WantToBeVisibleInInspector[] meWant;
}
SomeEnum shows on the inspector but the SomeClass does not.
Why does this occur and how to fix it?

Autofac: registering hierarchy of classes

I am struggling to register with Autofac a hierarchy of classes and interfaces.
I have an interface IMyService defined as below:
public interface IMyService
{
void DoMyService();
}
And I have two abstract classes with implement this interface and called MyServiceA, and MyServiceB:
public abstract class MyServiceA : IMyService
{
public abstract DoMyService();
}
public abstract class MyServiceB : IMyService
{
public abstract DoMyService();
}
Moreover I have a second-level hierarchy for each of the two aforementioned services: MyServiceA1, MyServiceA2, MyServiceB1 and MyServiceB2:
public class MyServiceA1 : MyServiceA
{
public MyServiceA1() : base() {}
public void DoMyService()
{
// Implementation goes here
}
}
public class MyServiceA2 : MyServiceA
{
public MyServiceA2() : base() {}
public void DoMyService()
{
// Implementation goes here
}
}
public class MyServiceB1 : MyServiceB
{
public MyServiceB1() : base() {}
public void DoMyService()
{
// Implementation goes here
}
}
public class MyServiceB2 : MyServiceB
{
public MyServiceB2() : base() {}
public void DoMyService()
{
// Implementation goes here
}
}
I have in input two enums FirstEnum and SecondEnum used to select which of the four concrete types to instantiate:
public enum FirstEnum
{
SvcA,
SvcB
}
public enum SecondEnum
{
Svc1,
Svc2
}
I want to register IMyService and by providing two enums, It will automatically instantiate the good concrete type.
For instance, if I want to resolve an IMyService and I provide FirstEnum.SvcB and SecondEnum.Svc2, it should instantiate the concrete type MyServiceB2 class. Moreover this hierarchy might be updated by adding some other concrete types etc, so I need a generic way of doing it
Does anyone have a clue to help me?
Thanks
If you want to create a specific service dynamically depending on a set of parameters, this is a good use case for an abstract factory:
public interface IMyServiceFactory
{
IMyService Create(FirstEnum e1, SecondEnum e2);
}
public class MyServiceFactory : IMyServiceFactory
{
private readonly ILifetimeScope scope;
public MyServiceFactory(ILifetimeScope scope)
{
if (scope == null)
throw new ArgumentNullException("scope");
this.scope = scope;
}
public IMyService Create(FirstEnum e1, SecondEnum e2)
{
if (e1 == FirstEnum.SvcA)
{
if (e2 == SecondEnum.Svc1)
{
return scope.Resolve<MyServiceA1>();
}
else //svc2
{
return scope.Resolve<MyServiceA2>();
}
}
else //B
{
if (e2 == SecondEnum.Svc1)
{
return scope.Resolve<MyServiceB1>();
}
else //svc2
{
return scope.Resolve<MyServiceB2>();
}
}
}
}
And now your consumer need to get the factory injected instead of the service:
public class MyServiceConsumer
{
private readonly IMyServiceFactory factory;
public MyServiceConsumer(IMyServiceFactory factory)
{
this.factory = factory;
}
public void Do()
{
//var service = this.factory.Create
}
}
Registration :
Autofac.ContainerBuilder builder = new Autofac.ContainerBuilder();
builder.RegisterType<MyServiceA1>().AsSelf().AsImplementedInterfaces();
builder.RegisterType<MyServiceA2>().AsSelf().AsImplementedInterfaces();
builder.RegisterType<MyServiceB1>().AsSelf().AsImplementedInterfaces();
builder.RegisterType<MyServiceB2>().AsSelf().AsImplementedInterfaces();
builder.RegisterType<MyServiceFactory>().As<IMyServiceFactory>();
builder.RegisterType<MyServiceConsumer>();
//and quick test resolve
var container = builder.Build();
var test = container.Resolve<MyServiceConsumer>();

Interface in java

interface A {
public void eg1();
}
interface B {
public void eg1();
}
public class SomeOtherClassName implements A, B {
#Override
public void eg1() {
System.out.println("test.eg1()");
}
}
What is the output and what occurs if method is overriden in interface?
First of all it's of no use to implement both class A and B as both
of them has same method signature i.e both has same method name and
return type.
Secondly you'll need a main method to run the program.
Also in interface you can only declare the methods, the implementation
has to be done in the class which implements it.
interface A {
public void eg1();
}
interface B {
public void eg1();
}
public class Test implements A{
#Override
public void eg1() {
System.out.println("test.eg1()");
}
public static void main (String args[]) {
A a = new test();
a.eg1();
}
}
Output : test.eg1()

Mapstruct passing enclosed object to the mapping method

Is there a way to pass the enclosed object reference as a parameter to the mapping method?
public class Car {
public int id;
public Person driver;
}
public class Person {
public int carId;
}
I need a reference to the enclosing car object when mapping the person object in the personToPersonDtoAfterMapping custom method.
#Mapper
public abstract class CarMapper {
public abstract CarDto carToCarDto(Car car);
public abstract PersonDto personToPersonDto(Person person);
#AfterMapping
protected void personToPersonDtoAfterMapping(Person person, #MappingTarget PersonDto dto, Car enclosedCar) {
dto.setCarId(enclosedCar.getId())
}
}
Simply use #Context annotation. Did you try?
#Mapper
public abstract class CarMapper {
public abstract CarDto carToCarDto(Car car);
public abstract PersonDto personToPersonDto(Person person, #Context Car enclosedCar);
#AfterMapping
protected void personToPersonDtoAfterMapping(Person person, #MappingTarget PersonDto dto, #Context Car enclosedCar) {
dto.setCarId(enclosedCar.getId())
}
}

How to Register a conventional Interface in Autofac

I have an autofac DI in my project.
I want to expose an interface by conventional which all other interfaces of my project will inherit from. Is it possible to automatically register the components of the inherited interfaces at start up level? For example:
Public interface IConvetionInterface {}
public interface IImplementationA:IConvetionInterface
{
public void DoSomethingA();
}
public interface IImplementationB:IConvetionInterface
{
public void DoSomethingB();
}
Injecting through constructor;
public class ConsumerA
{
private readonly IImplementationA _a;
public DealerRepository(IImplementationA A)
{
_a= A;
}
public Act()
{
_a.DoSomethingA();
}
}
How do I register IConvetionInterface to make all its dependencies resolve in Autofac.
I have been able to come up with this solution by using autofac Assembly Scanning Configuration as provided in their documentation page Autofac Documentation Page
I have an open generic interface
public interface IRepository<TEntity, TPrimaryKey> where TEntity : class, IEntity<TPrimaryKey>
{ }
Implemented by
public class Repository<TEntity, TPrimaryKey> : RepositoryBase<TEntity, TPrimaryKey>
where TEntity : class, IEntity<TPrimaryKey>{}
Then, I created an empty interface
public interface IConventionDependency
{
}
This method was called to register my components at startup level:
public static void RegisterAPSComponents(ContainerBuilder builder)
{
builder.RegisterType<APSContext>().InstancePerRequest();
builder.RegisterGeneric(typeof(Repository<,>)).As(typeof(IRepository<,>)).InstancePerLifetimeScope();
builder.RegisterAssemblyTypes(typeof(IConventionDependency).Assembly).AssignableTo<IConventionDependency>().As<IConventionDependency>().AsImplementedInterfaces().AsSelf().InstancePerLifetimeScope();
}
By the above registration, any interface that inherits from IConventionDependency will be registered automatically in the container.
example:
create an interface:
public interface IDealerRepository : IConventionDependency
{
List<Dealers> GetDealers();
}
then Implement the interface :
public class DealerRepository : IDealerRepository
{
private readonly IRepository<VTBDealer, int> _repository;
public DealerRepository(IRepository<VTBDealer, int> repository)
{
_repository = repository;
}
public List<Dealers> GetDealers()
{
return _repository.GetAllList().MapTo<List<Dealers>>();
}
}
in conclusion, without explicitly registering IDealerRepository, it gets resolved in MVC Controller constructor.