.Net Class and API or some features that behave differently on each platform so we need to write some code on platform specific. Below two library for sharing code between multiple platform
  • Shared asset project ( SAP)
  • Portable Class library (PCL)
Share Project (SAP)

You can share code across multiple platform projects. Your Code is compiled as part of each referencing project and can include compiler directives to help incorporate platform-specific functionality into the shared code base.

Xamarin project template have standard for defining Build Symbol with double underscore pre and post – fix

 
 Build Symbol
  Description
__MOBILE__
Support iOS and Android specific code
__IOS__
iOS specific  code
__TVOS__
TV Specific Code
__WATCHOS__
Watch Specific code
__ANDROID__
Android Specific Code
__MAC__
Mac Specify Code
_WINDOWS_PHONE and SILVERLIGHT
Windows Phone Specific code

Visual Studio:

The compiler directives on your platform specific project. Right Click on your Platform Specific Project ➔ Click on property ➔ Select Build Option

Change the Configuration drop downs at the top of the Options to see the symbols for each different build configuration


Xamarin Studio:

Right-click Project > Options > Build > Compiler > Define Symbols.

Change the Configuration drop downs at the top of the Options to see the symbols for each different build configuration



Define symbol like below in shared project and Add reference into all the platform project and assign value into textbox control or others control

using System;

namespace DevXamarinForm.Shared
{
public class Common
{
public Common()
{
}
public string PrintText()
{
string printtext ="No Device Specfic";
#if __MOBILE__
printtext= "iOS or Android specific code";
#endif
#if __IOS__
printtext= "iOS specific code";
#endif
#if __TVOS__
printtext= tv specific stuff";
#endif
#if __ANDROID__
printtext="Android specific code";
#endif
#if _WINDOWS_PHONE
printtext="Android-specific code";
#endif
return printtext;
}
}
}

Portable Class library: [compiler directives do not work in PCLs]

Portable class libraries are platform independent. PCL do not allow to use conditional compilation .This is because PCL should work on all specified platforms which was chosen as a target and Also, availability of features depends on selected targets.

We can use same above way but that is not recommended way. Let we see how we will do same above

Step 1:

Create Class file like above under PCL project

Step 2:

Right Click Specific Platform project ➔ Add ➔ Existing Item ➔Select PCL project ➔ Select Common Class file ➔ select “Add as Link”



It will work same like Shared Project.

Recommended approach to writing platform conditional code in a PCL:

The Device class contains a number of properties and methods to help developers customize layout and functionality on a per-platform basis.

using System;
using Xamarin.Forms;

namespace DevXamarinForm
{
public class Common
{
public Common()
{
}
public string PrintText()
{
string printtext = "No device Specfic Device";
if (Device.OS == TargetPlatform.iOS)
{
printtext = "iOS specific code";
}
else if (Device.OS == TargetPlatform.Android)
{
printtext = "Android specific code";
}
else if (Device.OS == TargetPlatform.Windows)
{
printtext = "Windows specific code";
}
else if (Device.OS == TargetPlatform.WinPhone)
{
printtext = "Winphone specific code";
}
else if (Device.OS == TargetPlatform.Other)
{
printtext = "Other specific code";
}
return printtext;
}
}
}

Output:

Mobile Application planning, development, testing and deployment go well as per the customer estimation but after a while the client was clamoring that the app is getting slower and slower when it was continuously being used up to the point where it will just crash suddenly but most of the developer unaware why it’s like this. In this article, you are going to learn how to use prevent memory leak and profiler in Xamairn Application.


Garbage Collection:

We all know that in the .NET world we have a very good friend called Garbage Collector. Basically, it is responsible on freeing up the used memory. As simple as it sounds, whether you are in a Desktop, Web or especially mobile where there are two worlds one is Managed and the other one is the native part which at times Garbage Collection is not enough to reclaim those used memories the cause of the slowdown Mobile app is due to Memory Leaks.


Beware of common memory leak sources:

You do incorrect memory management wherein an object is stored in memory but cannot be accessed by the running code, it’s always causing a memory leak in mobile application. We all Knows what we can’t do but still we are doing as like below image, Same in Mobile Development also we all knows what can’t do, but still we are doing same mistake.




I suggest to be extra careful when using below C# feature, and proactively check for memory leaks with techniques like the last best practice.

Events, delegates or Messaging Centers in .NET are notorious for causing memory leaks. You can innocently subscribe to an event, causing a damaging memory leak without even suspecting.

Custom control and Unknown Nuget package are event registered, such as Loaded, will not be unloaded until all events are unregistered. Always remember to unregister your events when you don't need them anymore and we are not sure all the objects or disposed.

Images is a classical .net GC-Java GC problem when GC isn't aware of image size and won't release reference unless it is Disposed.

Static variables, collections, and static events in-particular should always look suspicious. Remember that all static variables are GC Roots, so they are never collected by the GC.

Caching functionality in mobile apps is necessary, any type of caching mechanism can easily cause memory leaks. By storing cache information in-memory, eventually, it will fill up and cause an OutOfMemory exception.

Bindings can be dangerous. The rule of thumb is to always bind to a DependencyObject or to a INotifyPropertyChanged object. When you fail to do so, Xamarin will create a strong reference to your binding source (meaning the ViewModel) from a static variable, causing a memory leak

Threads that never terminate – The Live Stack of each of your threads is considered a GC Root. This means that until a thread terminates, any references from its variables on the Stack will not be collected by the GC. This includes Timers as well. If your Timer’s Tick Handler is a method, then the method’s object is considered referenced and will not be collected.
Preventing Memory Leaks:

Enterprise Mobile application knows memory leaks are like overloaded people in a Bus or train. You might not notice when there are few of them, but you always make sure people enter in the bus with very limited and identify bus capacity based on that you need to allow the people into the bus. In Mobile application you should define to developer with strike rule and TODO List and make sure your code review taken care following option for prevent memory leaks

Using Statement:

Xamairn Mobile application constantly uses unmanaged resources. The .NET framework itself relies heavily on unmanaged code for internal operations, optimization. Anytime you use Streams, Graphics, or Files for example, you are probably executing unmanaged code. The using statement transforms the code into a try / finally statement behind the scenes, where the Dispose method is called in the finally clause.

Dispose pattern:

You implement a Dispose method to release unmanaged resources used by your application. The .NET garbage collector does not allocate or release unmanaged memory. The Dispose method performs all object cleanup, so the garbage collector no longer needs to call the objects' Object.Finalize override. Learn more MSDN portal .

public void CreateFile()
{
using (var stream = new FileStream(@"\Document\SomeFile.txt",
FileMode.OpenOrCreate))
{
// do stuff
}// stream.Dispose() will be called even if an exception occurs


Test for memory leaks:

It’s a great practice to proactively test for memory leaks. And it’s not that hard. Here’s a short pattern you can use in the unit testing project.
[Test]
void MemoryLeakTest()
{
var weakRef = new WeakReference(leakyObject)
// Ryn an operation with leakyObject
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
Assert.IsFalse(weakRef.IsAlive);
}


Getting Started Profiling:


Xamarin Profiler is a great tool created by Microsoft wherein it gives developers ways to profile or collect telemetry with your Mobile Applications using Visual Studio. It can also be paired with native profilers, like Xcode Instruments and Android Profiler, to ensure better app behavior and performance. The main function of the profiler is to collect and displays information about the Mobile App wherein the Developer can pinpoint, analyze and optimize areas in their application for a smooth experience by end users. There are different ways the Xamarin Profiler can help us like statistical.




The Xamarin Profiler has many features Allocation, Cycles, Data presented on each screen and Time profiler. It’s a graphical interface for the Mono log profiler, and supports profiling for following platform in Windows and mac machine.

  • Android, iOS, tvOS, and Mac applications on Mac
  • Android, iOS, and tvOS applications on Windows.

In this section, will learn common profiling scenarios and analyze and optimize iOS and Android applications.

Prerequisites:

We need Visual Studio Enterprise subscriber to unlock Profiler feature in either Visual Studio Enterprise on Windows or Visual Studio for Mac on a Mac. Download install following package in your mac or windows machine.





After successful installation, let get satrt use Profiling in Xamarin iOS and android application. Integrate Profiling is very simple steps, you need changes Project Property options in iOS and Android Project.

Create new Xamairn Forms project using Visual Studio and Select iOS and Android platform is supported and follow below two steps for enabling the profiling in iOS and Android Project.
Android:

In Android Project, Right click on project > Select property > Select “Android Options” > Select options “Enable developer instrumentation”.


iOS

In iOS Project, Right click on Project > Select Property > Select “iOS Debug” Options and check the check box “Enable Profiling”.


Start the Xamarin Profiler:

Step 1: Build and run the application in iOS or Android.

Step 2: In Visual Studio menu, Select Analyze or Tools main menu > Select Xamarin Profiler and open the Profiler and make sure before open profiler, the application needs to be built at least once in order to start a profiling session.





The Xamarin Profiler comes with following instruments:
  • All Instruments
  • Allocations.
  • Time Profiler.
Once you have selected a Allocations options and you can also configure some options of how the memory profiling will proceed. You can either customize the frames, frequency or either select from the presets as shown below image.


Once you have clicked the Start Profiling button it will automatically launch your selected application on the selected device and you will be greeted with this window


In that above image denoted number with green marked and detail info below

No 1 - Represents the actual graph of the Memory consumption with respect to time.


No 2 - Represents the different data categorized on your selected tab.


No 3 -Represents the information (Object name, count, size) displayed based on the selected tab.


No 4 - Represent the real time display of information based on the current snapshot.


No 5 - Represents the Selected device and the Application that is currently running.

Snapshots

Snapshots pane displays information about memory snapshots. To generate these while profiling a live application, click the Camera button in the toolbar at each point that you'd like to see what memory is retained and released. You can then click each snapshot to explore what is happening under the hood. Note that snapshots can only be taken when live profiling an app.



Time Profiler

The Time Profiler instrument measures exactly how much time is spent in each method of an application. The application is paused at regular intervals and a stack trace is run on each active thread. And Call Tree options will show amount of time spent in each method.


I hope you enjoyed for learning profiling and prevent memory leak issue. Let me state that Profilers are not only for memory leaks but also can be used in code optimization. Finally moving forward maybe you can also adapt or put in your development routine the profiling of your mobile applications.

Summary

I hope this article gave you some value to you, let we take a new year’s resolution is better memory management while doing C# programing. Please leave your feedback/query using the comments box, and if you like this article, please share it with your friends

Introduction :

Bot Framework enables you to build bots that support different types of interactions with users. You can design conversations in your bot to be free. Your bot can also have more guided interactions where it provides the users with choices or actions. The conversation can use simple text strings or more complex rich cards that contain text, images, and action buttons. And, you can add natural language interactions, which let your users interact with your bots in a natural and expressive way.

We are going to create and build Xamarin FAQ Bot using Azure Bot Service and deploy into Webchat .in this article, we are not going to write any coding for implement Xamarin FAQ Bot but be ready with what are the question and answer to train the Bot. I have already created 7000+ more Xamarin Q A as word document, we will use same document for upload and train knowledge base.


Create a QnA Service:

Step 1: 

Navigate to https://qnamaker.ai/ and Sign in using Microsoft Account.

Step 2: 

Click on “Create a knowledge base” from main menu

Step 3:

You can skip “Create a QnA service” step, let we publish QnA service after create knowledge base.


Step 4: 

Provide QnA Knowledge base basic information




Step 5:

 You can extract question and answer pairs from an online FAQ, manuals Entry and upload files with .tsv,.pdf,.doc,.docx,.xls format. If you are trying to enter manual entry skip this step.
Add chit-chat to your bot, to make your bot more conversational and engaging, with low effort. You can easily add chit-chat data sets for 3 pre-defined personalities when creating your KB, and change them at any timer. Chit-chat is supported for 3 predefined personalities

  • The Professional
  • The Friend
  • The Comic

Step 5:

 Click on “Create your KB”


Step 6: 

Wait for a few seconds for load all the knowledge base Q & A to the Online Editor.

Step 7: 

QnA service has loaded our FAQs Editor with two-column knowledge base, without any extra tweaking needed from you. Now you can edit and modify old Q&A and also Select Add new QnA pair to input other greetings and responses.




Step 8: 

The main menu having different option, Edit, Publish, Save, train, test and Settings. While click on Edit the above knowledge base edit screen will open, you can search and filter the question and Edit. After Edit always click on “Save and train” menu option for Save.


Step 9: 

Click on “Publish”. once you publish the knowledge base endpoint available for use in your bot or App

Step 10: 


The Knowledge base will generate following, you can make note. Need to update below details in Azure Hosting.
  • Knowledge base Key
  • Host Address
  • EndPointKey

Create and Publish QnA Bot in Azure:

Step 1: 

Navigate and Login to https://portal.azure.com/.

Step 2: 

Select + Create a resource > Select “AI Machine Learning” > Click on “Web App Bot”





Step 3: 

Let us start create Web App Bot, Provide the Bot Name, resource, location and also follow the step 4, Step 5 for select Bot template and prizing and click on Create.

Step 4: 

You can use the v3 templates, select SDK version of SDK v3 and SDK language of C# or Node.js. Select the Question and Answer template for the Bot template field, then save the template settings by selecting Select.



Step 5: 

You can choose a pricing tier for Bot Search service

 

Step 6: 

Review your settings, then select Create. This creates and deploys the bot service with XamarinQA to Azure .


Step 7: 

Open Xamarin BotQA App Service from All Resource > Application Settings and edit the QnAKnowledgebaseId, QnAAuthKey, and the QnAEndpointHostName fields to contain the values of your QnA Maker knowledge base. Like below


Test and Implement Web Chat App:

In the Azure portal, click on Test in Web Chat to test the bot and Click on Channel > Deploy bot Application to Web Chat and Implement into your Website or Application. 



Summary

In this article, you learned Create, train, and publish your QnA Maker knowledge base. I have created 7000+ Xamarin Q A knowledge base and deployed into my blog (www.devenvexe.com) and Xamarin Q A Facebook Page, you can try out for demo and If you have any questions/feedback/ issues, please write in the comment box.



Introduction:

Microsoft Cognitive services is set of cloud based intelligence APIs for building richer and smarter application development. Cognitive API will use for Search meta data from Photos and video and emotions, sentiment analysis and authenticating speakers via voice verification.



The Computer Vision API will help developers to identify the objects with access to advanced algorithms for processing images and returning image meta data information. In this article, you will learn about Computer Vision API and how to implement Compute Vision API into Bot application.

You can follow below steps for implement object detection in Bot Application

Computer Vision API Key Creation:

Computer Vision ApI returns information about visual content found in an image. You can follow below steps for create Vision API key.
Navigate to https://azure.microsoft.com/en-us/try/cognitive-services/

Click on “Get API Key “or Login with Azure login.
Login with Microsoft Account and Get API key 


Copy API key and store securely, we will use this API key into our application

Step 2: 

Create New Bot Application:

Let's create a new bot application using Visual Studio 2017. Open Visual Studio > Select File > Create New Project (Ctrl + Shift +N) > Select Bot application.



The Bot application template gets created with all the components and all required NuGet references installed in the solutions.



In this solution, we are going edit Messagecontroller and add Service class.
Install Microsoft.ProjectOxford.Vision Nuget Package:
The Microsoft project oxford vision nuget package will help for access cognitive service so Install “Microsoft.ProjectOxford.Vision” Library from the solution


Create Vision Service:

Create new helper class to the project called VisionService that wraps around the functionality from the VisionServiceClient from Cognitive Services and only returns what we currently need. 

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Web;
using Microsoft.ProjectOxford.Vision;
using Microsoft.ProjectOxford.Vision.Contract;
namespace BotObjectDetection.Service
{
public class VisionService : ICaptionService
{
/// <summary>
/// Microsoft Computer Vision API key.
/// </summary>
private static readonly string ApiKey = "<API Key>";
/// <summary>
/// The set of visual features we want from the Vision API.
/// </summary>
private static readonly VisualFeature[] VisualFeatures = { VisualFeature.Description };
public async Task<string> GetCaptionAsync(string url)
{
var client = new VisionServiceClient(ApiKey);
var result = await client.AnalyzeImageAsync(url, VisualFeatures);
return ProcessAnalysisResult(result);
}
public async Task<string> GetCaptionAsync(Stream stream)
{
var client = new VisionServiceClient(ApiKey);
var result = await client.AnalyzeImageAsync(stream, VisualFeatures);
return ProcessAnalysisResult(result);
}
/// <summary>
/// Processes the analysis result.
/// </summary>
/// <param name="result">The result.</param>
/// <returns>The caption if found, error message otherwise.</returns>
private static string ProcessAnalysisResult(AnalysisResult result)
{
string message = result?.Description?.Captions.FirstOrDefault()?.Text;
return string.IsNullOrEmpty(message) ?
"Couldn't find a caption for this one" :
"I think it's " + message;
}
}
}
In the above helper class, replace vision API key and call the Analyze image client method for identify image meta data

Messages Controller:

MessagesController is created by default and it is the main entry point of the application. it will call our helper service class which will handle the interaction with the Microsoft APIs. You can update “Post” method like below 

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Web.Http;
using BotObjectDetection.Service;
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Connector;
namespace BotObjectDetection
{
[BotAuthentication]
public class MessagesController : ApiController
{
private readonly ICaptionService captionService = new VisionService();
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
public async Task<HttpResponseMessage> Post([FromBody]Activity activity)
{
if (activity.Type == ActivityTypes.Message)
{
//await Conversation.SendAsync(activity, () => new Dialogs.RootDialog());
var connector = new ConnectorClient(new Uri(activity.ServiceUrl));
string message;
try
{
message = await this.GetCaptionAsync(activity, connector);
}
catch (Exception)
{
message = "I am object Detection Bot , You can Upload or share Image Url ";
}

Activity reply = activity.CreateReply(message);
await connector.Conversations.ReplyToActivityAsync(reply);
}
else
{
HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return response;
}

private Activity HandleSystemMessage(Activity message)
{
if (message.Type == ActivityTypes.DeleteUserData)
{
// Implement user deletion here
// If we handle user deletion, return a real message
}
else if (message.Type == ActivityTypes.ConversationUpdate)
{
// Handle conversation state changes, like members being added and removed
// Use Activity.MembersAdded and Activity.MembersRemoved and Activity.Action for info
// Not available in all channels
}
else if (message.Type == ActivityTypes.ContactRelationUpdate)
{
// Handle add/remove from contact lists
// Activity.From + Activity.Action represent what happened
}
else if (message.Type == ActivityTypes.Typing)
{
// Handle knowing tha the user is typing
}
else if (message.Type == ActivityTypes.Ping)
{
}
return null;
}
private async Task<string> GetCaptionAsync(Activity activity, ConnectorClient connector)
{
var imageAttachment = activity.Attachments?.FirstOrDefault(a => a.ContentType.Contains("image"));
if (imageAttachment != null)
{
using (var stream = await GetImageStream(connector, imageAttachment))
{
return await this.captionService.GetCaptionAsync(stream);
}
}
string url;
if (TryParseAnchorTag(activity.Text, out url))
{
return await this.captionService.GetCaptionAsync(url);
}

if (Uri.IsWellFormedUriString(activity.Text, UriKind.Absolute))
{
return await this.captionService.GetCaptionAsync(activity.Text);
}
// If we reach here then the activity is neither an image attachment nor an image URL.
throw new ArgumentException("The activity doesn't contain a valid image attachment or an image URL.");
}
private static async Task<Stream> GetImageStream(ConnectorClient connector, Attachment imageAttachment)
{
using (var httpClient = new HttpClient())
{
var uri = new Uri(imageAttachment.ContentUrl);
return await httpClient.GetStreamAsync(uri);
}
}
private static bool TryParseAnchorTag(string text, out string url)
{
var regex = new Regex("^<a href=\"(?<href>[^\"]*)\">[^<]*</a>$", RegexOptions.IgnoreCase);
url = regex.Matches(text).OfType<Match>().Select(m => m.Groups["href"].Value).FirstOrDefault();
return url != null;
}
}
}

Run Bot Application

The emulator is a desktop application that lets us test and debug our bot on localhost. Now, you can click on "Run the application" in Visual studio and execute in the browser


  • Test Application on Bot Emulator
  • You can follow the below steps to test your bot application.
  • Open Bot Emulator.
  • Copy the above localhost url and paste it in emulator e.g. - http://localHost:3979
  • You can append the /api/messages in the above url; e.g. - http://localHost:3979/api/messages.
  • You won't need to specify Microsoft App ID and Microsoft App Password for localhost testing, so click on "Connect".

Related Article:

I have explained about Bot framework Installation, deployment and implementation in the below article

Summary

In this article, you learned how to create an Intelligent Image Object Detection Bot using Microsoft Cognitive Computer Vision API. If you have any questions/feedback/ issues, please write in the comment box.

Introduction :

Bot Framework enables you to build bots that support different types of interactions with users. You can design conversations in your bot to be free. Your bot can also have more guided interactions where it provides the users with choices or actions. The conversation can use simple text strings or more complex rich cards that contain text, images, and action buttons. And, you can add natural language interactions, which let your users interact with your bots in a natural and expressive way.

The Bot Builder SDK for .NET is an easy-to-use framework for developing bots using Visual Studio in Windows but for Visual Studio for Mac, it is not available in the official release. I have modified the Bot Framework template to work on Visual Studio for Mac and started using all the Bot Framework features on my Mac machine.

In this article, I am showing how to create, build, and test a Bot application using a Mac machine.


Prerequisites

  • Download and install Visual Studio for Mac
  • Clone and download the Bot Framework Project Template for Mac.
  • Download and install the Bot Framework Emulator for Mac.
  • Configure and Register Project Template

Step 1

Clone and download the Bot Framework template for Mac from the following URL - https://goo.gl/9ivoov

Step 2

Open the *.Csproj file or Visual Studio solution.

Step 3

Select and right-click on “Project” from Visual Studio Mac > “Restore NuGet packages”.

Step 4

Right-click on Project, select the Project Options, select XSP Web server and expand the Run option. Update the port number to 3978 like in the below screen.



Step 5

Build the solution. If it has successfully completed the Build, the project template gets added into the "Custom Folders" from Visual Studio Preference.


Create a Bot Application

Let's start with creating a new bot application in Visual Studio for Mac. Open Visual Studio 2017, create a new project with C#. Select the Bot applications template as below.



Provide the project Name, solution name, and location as below.



The bot application gets created with all the components and all required NuGet references installed.


Update the code

The default application adds a simple code snippet and we have no need to change anything. If you want to test your custom message, you can change it like below.

You can find the messagereceiveAsync method from Dialogs/RootDialog.cs file. In this method, the activity.Text container will return the user text input so that you can reply to a message based on the input text.

private async Task MessageReceivedAsync(IDialogContext context, IAwaitable < object > result) {
var activity = await result as Activity;
// calculate something for us to return
int length = (activity.Text ? ? string.Empty).Length;
// return our reply to the user
//test
if (activity.Text.Contains("technology")) {
await context.PostAsync("Refer C# corner website for tecnology http://www.c-sharpcorner.com/");
} else if (activity.Text.Contains("morning")) {
await context.PostAsync("Hello !! Good Morning , Have a nice Day");
}
//test
else if (activity.Text.Contains("night")) {
await context.PostAsync(" Good night and Sweetest Dreams with Bot Application ");
} else if (activity.Text.Contains("date")) {
await context.PostAsync(DateTime.Now.ToString());
} else {
await context.PostAsync($ "You sent {activity.Text} which was {length} characters");
}
Wait(MessageReceivedAsync);
}

Run Bot Application

Emulator is a desktop application that lets you test and debug your bot on localhost or remotely. Now, you can click on "Run the application" in any browser.


Install Bot Emulator

If you have not installed the Bot Emulator on Mac, you need to download and install the emulator for testing the bot application. You can download the Bot Emulator from - https://goo.gl/kZkoJT


Follow the below steps to test your bot application on Mac.

  • Open Bot Emulator.
  • Click "New Bot Configuration".
  • Copy the above localhost URL and paste it into the emulator. For example - http://127.0.0.1:3978
  • You can append the /api/message in the above URL; e.g. - http://127.0.0.1:3978/api/messages.
  • You won't need to specify the MSA ID and MSA password for localhost testing. So, click on "Save and Connect".


You can send a message to the bot application. The bot will reply as per your guide/code.


Summary

In this article, you learned how to create a bot application using Visual Studio for Mac. If you have any question, feedback, or issues, please write in the comment box.
Xamarin Developer Interview questions and answers Bot is ready to use in Line app. Xamarin FAQ Bot will be ready with 7000+ more Xamarin QnA’s. Now you can start open your Line App and > click on three dot line > Scan the following QR Code to add Xamarin QA bot as a friend.



Featured Post

Improving C# Performance by Using AsSpan and Avoiding Substring

During development and everyday use, Substring is often the go-to choice for string manipulation. However, there are cases where Substring c...

MSDEVBUILD - English Channel

MSDEVBUILD - Tamil Channel

Popular Posts