<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Akash Limbani on Medium]]></title>
        <description><![CDATA[Stories by Akash Limbani on Medium]]></description>
        <link>https://medium.com/@akashlimbani?source=rss-fbeca1de772b------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*UQv8fKx55LWL3maA4mei7A.png</url>
            <title>Stories by Akash Limbani on Medium</title>
            <link>https://medium.com/@akashlimbani?source=rss-fbeca1de772b------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 19:27:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@akashlimbani/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Big NEWS for .NET Developers]]></title>
            <link>https://akashlimbani.medium.com/big-news-for-net-developers-3b4704b118a7?source=rss-fbeca1de772b------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b4704b118a7</guid>
            <category><![CDATA[microsoft]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[dotnet-7]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Akash Limbani]]></dc:creator>
            <pubDate>Sat, 12 Nov 2022 18:18:48 GMT</pubDate>
            <atom:updated>2022-11-12T18:18:48.205Z</atom:updated>
            <content:encoded><![CDATA[<h3>Big NEWS for .NET Developers</h3><blockquote><strong><em>.NET 7 is released!</em></strong></blockquote><p>You can <a href="https://dotnet.microsoft.com/download/dotnet/7.0">download the free .NET 7 release</a> today for Windows, macOS, and Linux.</p><ul><li><a href="https://dotnet.microsoft.com/download/dotnet/7.0">Installers and binaries</a></li><li><a href="https://mcr.microsoft.com/catalog?search=dotnet/">Container images</a></li><li><a href="https://github.com/dotnet/core/blob/master/release-notes/7.0/">Linux packages</a></li><li><a href="https://github.com/dotnet/core/tree/master/release-notes/7.0">Release notes</a></li><li><a href="https://learn.microsoft.com/dotnet/core/compatibility/7.0">Breaking changes</a></li><li><a href="https://github.com/dotnet/core/blob/main/release-notes/7.0/known-issues.md">Known issues</a></li><li><a href="https://github.com/dotnet/core/issues">GitHub issue tracker</a></li></ul><p>.NET 7 provides a straightforward upgrade if you’re on a <a href="https://learn.microsoft.com/dotnet/fundamentals/implementations#net-5-and-later-versions">.NET Core version</a> and several compelling reasons to migrate if you’re currently maintaining a <a href="https://learn.microsoft.com/dotnet/fundamentals/implementations#net-framework">.NET Framework version</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*Tlq8ni76nKS1NgPxGd0wXw.jpeg" /></figure><blockquote>.NET Upgrade Assistant</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kBW6ypMPFBS4DFkmYjNaAg.jpeg" /></figure><blockquote>.NET in Ubuntu</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/861/1*t_tOKL4-QQmEiuAcBwMSjw.png" /></figure><blockquote>Wow, The Performance of .NET 7</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dntjPPXvA00AVJ3A99TVZQ.jpeg" /></figure><blockquote>.NET apps on ARM64</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fclP0ySX-5svBrcBqFEBsw.jpeg" /></figure><blockquote>Building cloud-native on Azure</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iVF4uZg7LghlL3f2NngENw.jpeg" /></figure><blockquote>Modern web with .NET</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E0OcYb4iSa5rf3QIfxNPTg.jpeg" /></figure><blockquote>Performance does matter of .NET 7</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*H8NkQDnMf3dsEwtEggM1PQ.jpeg" /></figure><blockquote>.NET REST APIs — Secure</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6u3aPbY-i6gJU0sC27s91g.jpeg" /></figure><p>Happy upgrading!</p><p>Keep Coding! 😊</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b4704b118a7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[   ]]></title>
            <link>https://akashlimbani.medium.com/-afd1e1e03d52?source=rss-fbeca1de772b------2</link>
            <guid isPermaLink="false">https://medium.com/p/afd1e1e03d52</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Akash Limbani]]></dc:creator>
            <pubDate>Wed, 19 Oct 2022 04:59:55 GMT</pubDate>
            <atom:updated>2022-10-19T04:59:55.300Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/982/1*9AVXxNp1qo5_-KUktGN2YQ.png" /></figure><p>𝐌𝐚𝐤𝐞 𝐢𝐭 𝐰𝐨𝐫𝐤<br>This is the first and most important principle in your everyday job. This may be obvious, but it’s good to remember that all the follow-up principles work best on code that does the job.</p><p>𝐘𝐀𝐆𝐍𝐈<br>The second most important thing to assure is to remove unnecessary code. Because we first made it work, all the logic is already in the code — we won’t need to add any code that brings business value. YAGNI on top of that guarantees that we don’t have unnecessary code as well.</p><p>𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 𝐨𝐟 𝐥𝐞𝐚𝐬𝐭 𝐬𝐮𝐫𝐩𝐫𝐢𝐬𝐞<br>Now let’s make sure that the remaining code surprises other people as little as possible. If this happens to be the last rule you apply, your code could be unclean or have other flaws — but at least it’s not surprising to anyone. This trait — predictability — encourages other people to improve it, if necessary.</p><p>𝐊𝐈𝐒𝐒<br>Only after that, it’s time to keep it simple. I believe it’s less important than not surprising. I would rather work with complex, but not surprising code, than the other way around. It’s easier to simplify code if you can get the idea behind it, and the latter is greatly easier if the code is not surprising.</p><p>𝐁𝐞 𝐂𝐨𝐧𝐬𝐢𝐬𝐭𝐞𝐧𝐭<br>Now it’s time to care for consistency. I would rather work with inconsistent, but simple code than the other way around. It’s easier to make code consistent than to make it less complex preserving consistency.</p><p>𝐃𝐑𝐘<br>I guess this one being so high could surprise a lot of people, but I think DRY is somewhat overrated. Maybe because it’s brain-dead simple to trot out and blindly follow, but hard to spot the danger of it. For example, abstracting a KISS-less code can lead to wrong abstractions.</p><p>𝐂𝐥𝐞𝐚𝐧 𝐜𝐨𝐝𝐞<br>Now when we don’t repeat ourselves, it’s time for meaningful names, short methods, etc. This one should be already partially applied by DRY anyway. As much as I’m a fan of clean code, I believe that prior to this point there were more urgent issues to fix.</p><p>𝐒𝐎𝐋𝐈𝐃<br>In short, this seems to me as the natural continuation of the previous step for the design level — “clean design”, so to speak. Clean code is higher because it makes keeping a clean design easier.</p><p>𝐃𝐞𝐬𝐢𝐠𝐧 𝐩𝐚𝐭𝐭𝐞𝐫𝐧𝐬(if necessary)<br>This step I would explain this as “add complexity to areas where you already identified common issues”.</p><p>𝐀𝐠𝐢𝐥𝐞 𝐏𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐬<br>In order to have adaptive software, we might want to add some patterns and abstractions to it.</p><p>𝐁𝐨𝐲 𝐒𝐜𝐨𝐮𝐭 𝐑𝐮𝐥𝐞<br>It’s nice to clean your borough, but not before making your code right. This principle is kind of meta to me: it doesn’t tell what to do with your code, but rather when (always) and how much (not too much).</p><p>𝐌𝐚𝐤𝐞 𝐈𝐭 𝐅𝐚𝐬𝐭<br>This one is normally applied after a noticeable time, after measurements.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=afd1e1e03d52" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[    ]]></title>
            <link>https://akashlimbani.medium.com/-e30b4b4bf7d0?source=rss-fbeca1de772b------2</link>
            <guid isPermaLink="false">https://medium.com/p/e30b4b4bf7d0</guid>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[blazor]]></category>
            <category><![CDATA[dot-net-developers]]></category>
            <category><![CDATA[razor]]></category>
            <dc:creator><![CDATA[Akash Limbani]]></dc:creator>
            <pubDate>Thu, 04 Aug 2022 07:43:39 GMT</pubDate>
            <atom:updated>2022-08-04T07:43:39.673Z</atom:updated>
            <content:encoded><![CDATA[<p>As the name of Blazor itself comes from combining the two terms “Browser” and “Razor”, we can see that there’s a relationship between the two.</p><p>Both Razor and Blazor are Microsoft products that use C# and HTML to develop web apps. They are free and open-source, allowing developers to quickly and freely use these technologies. We use the Razor syntax when creating <a href="http://asp.net/">ASP.NET</a> web apps, where Blazor shows more similarity to <a href="http://asp.net/">ASP.NET</a> Core and <a href="http://asp.net/">ASP.NET</a> MVC.</p><p>Blazor uses Razor as the template syntax for creating user interfaces, making Blazor act as a client-side hosting model for Razor components. Using Razor-based components with Blazor allows developers to break down individual features into tiny, easy-to-build components and then assemble these components to build a much larger app efficiently.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e30b4b4bf7d0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Most Useful Command for .NET]]></title>
            <link>https://akashlimbani.medium.com/most-useful-command-for-net-b0ecd384ca0b?source=rss-fbeca1de772b------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0ecd384ca0b</guid>
            <category><![CDATA[dot-net-developers]]></category>
            <category><![CDATA[designer]]></category>
            <category><![CDATA[commands]]></category>
            <category><![CDATA[dotnet]]></category>
            <category><![CDATA[development]]></category>
            <dc:creator><![CDATA[Akash Limbani]]></dc:creator>
            <pubDate>Fri, 08 Jul 2022 18:13:24 GMT</pubDate>
            <atom:updated>2022-07-08T18:13:24.785Z</atom:updated>
            <content:encoded><![CDATA[<h3>Most Useful Command for .NET</h3><p>As you all know .NET is now Open Source, Cross-platform and Free. So if you need to develop a .NET application on Linux or Mac OS you can.</p><p>.NET and with it the ability to use .NET cross-platform. With .NET came also a very capable CLI tool. Using the old .NET you knew there was an MSBuild command in the background but you seldom needed to care, Visual Studio handled it all for you.</p><p>Using .NET though you have the best of both worlds, still the first-class experience of either Visual Studio or the amazing Visual Studio Code, and with the CLI tool, we have a first-rate terminal experience as well.</p><p>If you are a UI designer then you need to know about .NET Commands Because, Choosing your own editor, also allows you to use the favorite editor of your choice. We all have our favorite editor. .NET used to be very tightly coupled to Visual Studio, now with .NET CLI you can quite easily build, test, package, and publish your projects through the terminal.</p><p>Here, I describe the 10 most useful commands of .NET</p><h3>1. dotnet new</h3><p>This command helps you scaffold a project. So usually you call it like this.</p><pre><strong><em>dotnet new</em></strong> &lt;TEMPLATE&gt; [--dry-run] [--force] [-lang|--language {&quot;C#&quot;|&quot;F#&quot;|VB}] [-n|--name &lt;OUTPUT_NAME&gt;] [--no-update-check] [-o|--output &lt;OUTPUT_DIRECTORY&gt;] [Template options]</pre><p>a real example is</p><pre>dotnet new console -o app</pre><p>The above will create a console project in the directory app. There&#39;s a lot more to this command like for web, MVC, etc.</p><h3>2. dotnet restore</h3><p>This restores the dependencies of a project. What does that mean exactly? Well, when you have added NuGet packages to your solution that add a reference to your project file, your .csproj. If you check out the project from GitHub those packages are maybe not versioned and will need to be added to your project. Running restore at this point will fetch the packages from the NuGet repository.</p><pre><strong><em>dotnet restore</em></strong> [&lt;ROOT&gt;] [--configfile &lt;FILE&gt;] [--disable-parallel]     [-f|--force] [--force-evaluate] [--ignore-failed-sources]     [--interactive] [--lock-file-path &lt;LOCK_FILE_PATH&gt;] [--locked-mode]     [--no-cache] [--no-dependencies] [--packages &lt;PACKAGES_DIRECTORY&gt;]     [-r|--runtime &lt;RUNTIME_IDENTIFIER&gt;] [-s|--source &lt;SOURCE&gt;]     [--use-lock-file] [-v|--verbosity &lt;LEVEL&gt;]</pre><h3>3. dotnet build</h3><p>This command builds a project and all of its dependencies. If you are at the root directory and you have a solution, then it will build the whole solution, so all projects are within the solution. If you are in a specific project directory then it will only build that directory, the <em>where</em> matters.</p><pre><strong><em>dotnet build</em> </strong>[&lt;PROJECT&gt;|&lt;SOLUTION&gt;] [-a|--arch &lt;ARCHITECTURE&gt;]     [-c|--configuration &lt;CONFIGURATION&gt;] [-f|--framework &lt;FRAMEWORK&gt;]     [--force] [--interactive] [--no-dependencies] [--no-incremental]     [--no-restore] [--nologo] [--no-self-contained] [--os &lt;OS&gt;][-o|--output &lt;OUTPUT_DIRECTORY&gt;] [-r|--runtime &lt;RUNTIME_IDENTIFIER&gt;]     [--self-contained [true|false]] [--source &lt;SOURCE&gt;][-v|--verbosity &lt;LEVEL&gt;] [--version-suffix &lt;VERSION_SUFFIX&gt;]</pre><h3>4. dotnet run</h3><p>The run command is what you use to execute your code.</p><p>To use it simply place yourself in the project directory of the project you want to run and type:</p><pre><strong><em>dotnet run</em></strong> [-a|--arch &lt;ARCHITECTURE&gt;] [-c|--configuration &lt;CONFIGURATION&gt;]     [-f|--framework &lt;FRAMEWORK&gt;] [--force] [--interactive]     [--launch-profile &lt;NAME&gt;] [--no-build]     [--no-dependencies] [--no-launch-profile] [--no-restore]     [--os &lt;OS&gt;] [--project &lt;PATH&gt;] [-r|--runtime &lt;RUNTIME_IDENTIFIER&gt;]     [-v|--verbosity &lt;LEVEL&gt;] [[--] [application arguments]]</pre><p>It’s used in the context of projects, not built assemblies. If you’re trying to run a framework-dependent application DLL instead, you must use dotnet without a command. For example, to run myapp.dll</p><h3>5. dotnet test</h3><p>This command is what you use to execute the tests of a test project. This comes with quite a few arguments which enable you to run specific tests or the whole test suite.</p><pre><strong><em>dotnet test</em></strong><em> </em>[&lt;PROJECT&gt; | &lt;SOLUTION&gt; | &lt;DIRECTORY&gt; | &lt;DLL&gt; | &lt;EXE&gt;]     [-a|--test-adapter-path &lt;ADAPTER_PATH&gt;] [--arch &lt;ARCHITECTURE&gt;]     [--blame] [--blame-crash]     [--blame-crash-dump-type &lt;DUMP_TYPE&gt;] [--blame-crash-collect-always] [--blame-hang] [--blame-hang-dump-type &lt;DUMP_TYPE&gt;]     [--blame-hang-timeout &lt;TIMESPAN&gt;]     [-c|--configuration &lt;CONFIGURATION&gt;]     [--collect &lt;DATA_COLLECTOR_NAME&gt;]     [-d|--diag &lt;LOG_FILE&gt;] [-f|--framework &lt;FRAMEWORK&gt;]     [--filter &lt;EXPRESSION&gt;] [--interactive]     [-l|--logger &lt;LOGGER&gt;] [--no-build]     [--nologo] [--no-restore] [-o|--output &lt;OUTPUT_DIRECTORY&gt;] [--os &lt;OS&gt;] [-r|--results-directory &lt;RESULTS_DIR&gt;] [--runtime &lt;RUNTIME_IDENTIFIER&gt;] [-s|--settings &lt;SETTINGS_FILE&gt;] [-t|--list-tests] [-v|--verbosity &lt;LEVEL&gt;]     [&lt;args&gt;...][[--] &lt;RunSettings arguments&gt;]</pre><h3>6. dotnet pack</h3><p>Now, we are getting into an interesting area namely creating your own NuGet packages. You create a package with this command and you can have packages in a local repository as well as the official global one.</p><pre><strong><em>dotnet pack</em></strong> [&lt;PROJECT&gt;|&lt;SOLUTION&gt;] [-c|--configuration &lt;CONFIGURATION&gt;]     [--force] [--include-source] [--include-symbols] [--interactive] [--no-build] [--no-dependencies] [--no-restore] [--nologo] [-o|--output &lt;OUTPUT_DIRECTORY&gt;] [--runtime &lt;RUNTIME_IDENTIFIER&gt;] [-s|--serviceable] [-v|--verbosity &lt;LEVEL&gt;]     [--version-suffix &lt;VERSION_SUFFIX&gt;]</pre><h3>7. dotnet sln</h3><p>This is the command you use to manage your solution. If you are completely new to dotnet, a solution keeps track of many projects and it’s a great way of managing a group of different projects that logically belongs together to do things like building or maybe publishing an executable. Because this command manages everything around solutions it’s good to know how to start out.</p><p>To create a solution you just place yourself in a directory of your choosing and run</p><pre><strong><em>dotnet new sln</em></strong></pre><p>This will create a solution file with the same name as the directory. For example:</p><pre>cd hello<br>dotnet new sln</pre><p>This will create a hello.sln file. To manage the solution you have the following commands at your disposal:</p><ul><li>add, this will add a project to your solution.</li><li>remove, this will remove a project from your solution</li><li>list, this lists all the projects in a solution</li></ul><h3>8. dotnet add/remove reference</h3><p>This command will add a project to your project. The purpose is for example for your project to use code from another project. For that to be possible, you first need to add a reference to that project before the compiler and your IDE will recognize it. For example, you are currently developing the console project app and you want to add the project lib to app. You can do this in one of two ways:</p><ol><li>Add a reference from solution dir, if you are standing in the solution directory (one level above the app directory) then you type</li></ol><pre><strong><em>dotnet add</em></strong> app/app.csproj reference lib/lib.csproj</pre><ol><li>Add a reference from the current directory, then you would type</li></ol><pre><strong><em>dotnet add</em></strong> reference lib1/lib1.csproj</pre><h3>9. dotnet add/remove package</h3><p>Now, We are again talking about NuGet packages. The add command allows us to add a package from NuGet by specifying it by name:</p><pre><strong><em>dotnet add package</em></strong> Newtonsoft.Json</pre><p>This will add Newtonsoft.Json package to our project file. It will also run a dotnet restore command which will fetch the package from NuGet&#39;s repository</p><h3>10. dotnet clean</h3><p>This command cleans the output of a project. This means it takes away both the contents of obj as well as bin folders. This command comes with a few arguments so you can for example choose to only clean a specific runtime or framework.</p><pre><strong><em>dotnet clean</em></strong> [&lt;PROJECT&gt;|&lt;SOLUTION&gt;] [-c|--configuration &lt;CONFIGURATION&gt;]     [-f|--framework &lt;FRAMEWORK&gt;] [--interactive]     [--nologo] [-o|--output &lt;OUTPUT_DIRECTORY&gt;]     [-r|--runtime &lt;RUNTIME_IDENTIFIER&gt;] [-v|--verbosity &lt;LEVEL&gt;]</pre><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0ecd384ca0b" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>