How can I add Console dll file in web application? - asp.net

Question

By following the CHATGPT guidelines I added a Console file dll (Inboundnightlybatchfile is my console file) in the bin folder of my web application. To access the dll need to import in our application. So I write this using Inboundnightlybatchfile; But the dll file name does not appear in the IntelliSense, and it throws a compile time error.
I want to add the Console file dll to an Web application

Answer 1

Well, HOW do you share ANY code in your existing application, or code from "other" applications?
why of course you have/put that code in a class.
I mean in your project now, how do you use/enjoy a bunch of helper code and routines?
You wind up with a class, and then in code create a instance of that class.
So, say I have a class that holds some information about a hotel?
Then you add a class to your project, and then simple use that class in code.
So, say this class:
Public Class Hotel
Public HotelName As String
Public City As String
Public HotelDescripiton As String
Public FirstName As String
Public Lastname As String
Public ReadOnly Property FullName As String
Get
Return FirstName & " " & Lastname
End Get
End Property
End Class
Then in code, you can use that "code"
eg:
Dim OneHotel As New Hotel
OneHotel.HotelName = "Super 8 Hotel"
OneHotel.FirstName = "John"
OneHotel.Lastname = "Smith"
Debug.Print(OneHotel.FullName)
Output:
John Smith
Same goes for a console application. If you want share that code, then move the console code you want to share to a class.
Say I have this console application. When I run it, it will display all my drives on the computer.
So, from command prompt I have this:
So, now lets say I want to use above in my web site - to display/list all the hard drives.
So, the code for above console application is this:
Sub Main()
Dim cMyCode As New clsSharedCode
Dim sDriveList As List(Of String)
sDriveList = cMyCode.GetDrives
For Each s As String In sDriveList
Console.WriteLine(s)
Next
End Sub
But, the "working" code for that console been moved to a class called clsSharedCode.
That is this:
Imports System.IO
Public Class clsSharedCode
Public Function GetDrives() As List(Of String)
Dim DriveList As New List(Of String)
Dim allDrives As DriveInfo() = DriveInfo.GetDrives
For Each d As DriveInfo In allDrives
Dim s As String
s = $"Drive:{d.Name} Volume:{d.VolumeLabel} Type:{d.DriveType} Ready:{d.IsReady}"
DriveList.Add(s)
Next
Return DriveList
End Function
End Class
Ok, so now lets use above in our web site.
We simple set a reference to vbconsole.exe.
So, now this web page markup:
<h3>Drives on computer</h3>
<asp:ListBox ID="ListBox1" runat="server" Height="223px" Width="423px">
</asp:ListBox>
code behind
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
If Not IsPostBack Then
Dim cConsoleCode As New VBConsole.clsSharedCode
Dim sDriveList As New List(Of String)
sDriveList = cConsoleCode.GetDrives
For Each sDrive As String In sDriveList
ListBox1.Items.Add(sDrive)
Next
End If
End Sub
And then we get this:
So, to "share" code? How this works EVEN with a simple plain jane console application is quite much the same as you "always" done this.
This does mean/suggest that the working code in your console application should be moved out to a shared code class that BOTH the console application, and now your web application can use and enjoy.
But, be a a web site, or even a simple console application?
The why and how of sharing the code quite much is the same in .net. You share code by using a object approach, and this is quite much the WHOLE foundation as to how .net code works - including that of sharing code between systems and applications.
So, in my web application, I simple set a reference to vbconsole.exe, and now I am free to use + consume any code in that console appliation. however, as noted, like you ALWAYS done to share code? You will as a general rule move that code out to a class, and then any other application is free to consume + use that code by using the public class code you have in that application. So, that MySharedCode class in the console application can now be used by any other .net application, include that asp.net web site.
so, .net is "primarily" a object based system, and this is the main pillar and foundation of how you re-use and share .net code. You share such code by creating class(s) with that code, so then your existing application (the console application) can use those class(s), and as above shows, by a simple reference to the vbconsole.exe application, the web site can also use + enjoy + consume that code also.
So, becasue a class forces you to seperate out the UI parts from the code parts, then even adopting this approach in a simple console application means that such code can be used + consumed by any type of application. you can write another console applcation, and reference our above console application and use that code.
but, we can also create a windows desktop program, and again reference the vbconsole.exe application. And so can our web based applcation.
And even MORE amazing? You can consume the above class in c#, or vb.net, and again it don't matter!