Adam Things

ASP.Net Page Syntax Code Blocks

.Net, Coding, CSharp

ASP.Net Page Syntax Code Blocks

The <%# %> is used for data binding. This data binding expression creates a binding between a property on an ASP.NET page and a data source when the DataBind method is called. Data binding expressions can be included on the value side of an attribute/value pair in a server control or anywhere on the page. All data binding expressions on a page must be put between the <%# and %> characters. Here would be an example of using a data binding expression to bind to a server control.

<form runat="server">
    <asp:DropDownList id="List" runat="server">
        <asp:ListItem>Adam</asp:ListItem>
        <asp:ListItem>Anthony</asp:ListItem>
    <asp:ListItem>Ryan</asp:ListItem>
    </asp:DropDownList>
    <asp:button Text="Submit" OnClick="SubmitBtn_Click" runat="server"/>
    <p>
        Selected Name: <asp:label text='<%# List.SelectedItem.Text %>' runat="server"/>
    </p>
</form>

The <%= %> symbols are used to display information. The value that gets entered in between the symbols will be written out to the current page. These symbols will be executed and displayed when they appear on the page. So a quick example would be having a variable named Transportation. Let’s say the value of that variable is equal to Truck. With that in mind, let’s look at how this would be used in the mark up.

I drive a <%= Transportation %>! //Code
I drive a Truck! //Output

The <% %> symbols are used for Embedded code blocks. The embedded code block is server code and is executed during the pages render. The block can be used to execute programming statements or call functions in the current page class. Here is a simple example from msdn. You’ll see how it uses the <% %> to encase the for loop that will then execute when the page renders.

<body>
    <form id="form1" runat="server">
        <% for(int i = 0; i < 6; i++) %>
        <% { Response.Write("<br>" + i.ToString()); }%>
    </form>
</body>

The <%– –%> is simply used to indicate a server side comment. These can be used anywhere within the page but cannot be used within the <script> tag. You also may not used a server side comment within an embedded code block. So if you have a <%– –%> inside of a <% %> it will result in a compilation error.

<%--
    <asp:button runat="server" id="MyButton"
    OnClick="MyButton_Click" />
--%>

The <%@ %> is used to used to signify a page directive. ASP.Net includes many different directives which are as follows. Taken right from msdn.

@ Page Defines page-specific attributes used by the ASP.NET page parser and compiler. Can be included only in .aspx files.
@ Control Defines control-specific attributes used by the ASP.NET page parser and compiler. Can be included only in .ascx files (user controls).
@ Import Explicitly imports a namespace into a page or user control.
@ Implements Declaratively indicates that a page or user control implements a specified .NET Framework interface.
@ Register Associates aliases with namespaces and class names, thereby allowing user controls and custom server controls to be rendered when included in a requested page or user control.
@ Assembly Links an assembly to the current page during compilation, making all the assembly's classes and interfaces available for use on the page.
@ Master Identifies an ASP.NET master page.
@ WebHandler Identifies an ASP.NET IHttpHandler page.
@ PreviousPageType Provides the means to get strong typing against the previous page as accessed through the PreviousPage property.
@ MasterType Assigns a class name to the Master property of an ASP.NET page, so that the page can get strongly typed references to members of the master page.
@ OutputCache Declaratively controls the output caching policies of a page or user control.
@ Reference Declaratively links a page or user control to the current page or user control.

It is important to note that if you do not specify one, the default then becomes the @ Page directive.

The <%: %> symbols were introduced in ASP.NET 4 and it works much like the <%= %> but it will also automatically HTML encode the output. In the example below, you will notice that the second one does the encoding for you and helps save some space.

<div id="OldWay">
    <%= Server.HtmlEncode(Model.Content) %>
</div>
<div id="NewdWay">
    <%: Model.Content %>
</div>

I got tired of trying to look them up every time so I decided to consolidate them into one place for quick reference.


Ensure Threads Have Finished Before Method Continues

.Net, Coding, CSharp, ,

**Update – Please see here for a better way of doing this.  It’s a better solution that came around after writing this post.

This post is part extension off of my Multithreading with Parameters.  I came into a spot where I am building a monitoring page that on page load, spins off about 20-30, and then displays the outcome of those threads.  However, if you spin off a bunch of threads and don’t do anything else, the page load method finishes and you’re left with little to no content on the page because it finished before your threads.  So I implemented a thread counter.  It was a simple solution and makes the method wait until all threads have completed before it can move on.
We need a few things; a counter object, a lock object, an increment method, and a decrement method.  These are pretty straight forward and are as follows.


protected static int threadCounter = 0;
protected static object lockObject = new object();

protected void IncrememntCounter()
{
    lock (lockObject)
    {
        threadCounter++; //Increment Thread Count By 1
    }
}

protected void DecrementCounter()
{
    lock (lockObject)
    {
        threadCounter--; //Decrement Thread Count By 1
    }
}

Now let’s look how this gets applied.  [more]In our method where we spin off the threads, we simply call the increment method.


//Create new thread
Thread logThread = new Thread(LogServiceCall); 
//Start new threadlog
Thread.Start(logParams);
//Increment our thread 
counterIncrementCounter();

As I am sure you have figured out, the method that gets spun off in the thread, we need to call the decrement counter upon completion of that method.


private void LogServiceCall(object parameterObject)
{
    LogginParams pLoggingParams = (LogginParams)parameterObject;
    lock (lockObject)
    {
        LogServiceCall(pLoggingParams.Log, pLoggingParams.Info, pLoggingParams.Number);
    }

    DecrementCounter();
}

Now we have our counter set up.  When we spin off a new thread we are adding one to the counter, and then when our thread finishes we are decrementing the counter by one. Now the last piece of the puzzle is in the method that you are wanting to wait for the threads to complete, we simply check our thread counter for number remaining.


while (threadCounter > 0)
{
    Thread.Sleep(500); //Make it pause for half second so that we don’t spin the cpu out of control.
}

This was a nice way to ensure threads have finished and that the method would not continue until everything was done.  My threads were small and often times finish quickly.  I added asynchronous threads and chopped the page loading speed over half.  If you have another way of going about doing this please share, I would love to hear to if there are better and different ways of doing this.


Error 1053 The service did not respond to the start or control request in a timely fashion.

.Net, Coding, CSharp, Windows Services

We had an issue arise lately where one of our servers got rebooted and the windows services on that box did not restart after the reboot like they should.  In the event logs, we were getting the following error.

Error 1053: The service did not respond to the start or control request in a timely fashion.

So after doing some research, it looked like we were doing too much in the Main() method and/or the constructor. In other words, all our processing was not finishing prior to timing out.  Now, we can start the services just fine after the box has booted.  So the issue is most likely while the box is being booted, its resources are too thin that even with the service set to Automatic (Delayed Start) that it’s just not finishing what it needs too.

So I dove into windows services a bit to figure out where we could move the bulk of our processing for initialization.  I came up with two solutions. First I recreated the problem so that I knew that’s what the real problem is. Take a look at the following.

using System.ServiceProcess;
using System.Threading;

namespace AdamsService
{
    public partial class Service1 : ServiceBase
    {
        //Called By Main Method.
        public Service1()
        {
            InitializeComponent();
        }

        //Runs First
        private static void Main()
        {
            ServiceBase[] ServicesToRun = new ServiceBase[] { new Service1() };

            Thread.Sleep(31000); //Simulates processing time leading to a time out.

            Run(ServicesToRun);
        }

        //Runs after main
        protected override void OnStart(string[] args)
        {
        }

        protected override void OnStop()
        {
        }
    }
}

This first example shows that the majority of the processing is happening in the Main() method.  As well, if you were to move the Thread.Sleep(31000) to the constructor Service1() you will get the same results.  If you build, deploy, and try to start this service locally you will receive a message like follows when you try to start the service.

Error 1053 Windows Service Fails To Start In Timely Fashion

Error 1053 Windows Service Fails To Start In Timely Fashion

So how do we fix it?  Let’s take a look at two solutions that seem to handle the extra processing time.  The first one, I basically moved the processing to the OnStart method.  This is run through the call in the Main method Run(ServicesToRun).  Moving the processing to OnStart allowed me to successfully start and run the service.

using System.ServiceProcess;
using System.Threading;

namespace AdamsService
{
    public partial class Service1 : ServiceBase
    {
        //Called By Main Method.
        public Service1()
        {
            InitializeComponent();
        }

        //Runs First
        private static void Main()
        {
            ServiceBase[] ServicesToRun = new ServiceBase[] { new Service1() };

            Run(ServicesToRun);
        }

        //Runs after main
        protected override void OnStart(string[] args)
        {
            Thread.Sleep(31000); //Simulates processing time leading to a time out.
        }

        protected override void OnStop()
        {
        }
    }
}

The second solution that seemed to work and seemed to be a common solution among others is to spin off a new thread from the Main() method.  This allows for almost instantaneously starting of the service and then the processing continues in the background.  Take a look at the following.

using System.ServiceProcess;
using System.Threading;

namespace AdamsService
{
    public partial class Service1 : ServiceBase
    {
        //Called By Main Method.
        public Service1()
        {
            InitializeComponent();
        }

        //Runs First
        private static void Main()
        {
            ServiceBase[] ServicesToRun = new ServiceBase[] { new Service1() };

            Thread worker = new Thread(DoProcessing);
            worker.IsBackground = false;
            worker.Start();

            Run(ServicesToRun);
        }

        private static void DoProcessing()
        {
            Thread.Sleep(31000);
        }

        //Runs after main
        protected override void OnStart(string[] args)
        {
        }

        protected override void OnStop()
        {
        }
    }
}

Both seem to work equally as well from the testing that I did.  I would be interested in others opinion if you have run into similar issues.


Rounding using Math Ceiling to 5 and 0 in CSharp

.Net, Coding, CSharp, ,

Rounding has always been a bit of a struggle.  Recently I had a requirement to do some rounding for a rating type of system (i.e. x / 5 stars).  As it has been long know, the Math.Round method handles .5 a bit differently than we would like.  So let’s take a look at the specific requirements and dig into this example a bit deeper.

If greater than .0 and less than or equal to .5, display half a star

If greater than .5 and less than or equal to .0 display whole star

This made for a little bit of a trickier approach since we are want a value such as 1.1 to round to 1.5 and then wanting 1.7 to round to 2.0.  When you start breaking it apart it’s not too bad.  We are going to take advantage of the Math.Ceiling method.  Math.Ceiling returns the smallest integral value that is greater than or equal to the specified double-precision floating-point number.  In a real basic sense it’s going to round the number up.  So in our context of ratings, the following ratings of say 1.2, 1.7, and 1.9 all will round up to 2.  How does this help us?  Let’s take a look at the line doing our rounding.

double roundedRating = (Math.Ceiling(2 * currentRating)) / 2;

I think the easiest way to understand is to plug in some numbers. Lets run an example.  So per our requirements, we would expect 1.1 to give us a final rounded rating of 1.5.

double roundedRating = (Math.Ceiling(2 * 1.1)) / 2;
double roundedRating = (Math.Ceiling(2.2)) / 2;
double roundedRating = (3) / 2;
double roundedRating = 1.5;

Following through the logic above, by doubling our initial rating, we are allowing ourselves to round to a whole number, and then divide that in half to achieve our .5 rating system that is required.  Overall, not entirely complicated but turned out to be a helpful little method to round to either .5 or .0 depending on the initial rating.


For Loop UInt64 MaxValue Parallel Iteration Calculation Time

.Net, Coding, CSharp, ,

For Loop UInt64 MaxValue Parallel Iteration Calculation Time was an interesting Friday 30 Second question; if you were to iterate through a loop and you could parallelize your loop over 100 cores and each iteration took 1 nanosecond (i.e. 1 billion iterations per second) then how long would it take you to iterate over all the digits that could fit inside an UInt64?

e.g.

for (UInt64 i = 0; i < UInt64.MaxValue; i++)
{    
    ; // This operation takes 1 nanosecond and loop has no overhead
}

So this is really just a math situation. First we need to define what the value of Uint64.MaxValue is.  If we look up its value on MSDN, we know that it is a constant value of 18,446,744,073,709,551,615; that is, hexadecimal 0xFFFFFFFFFFFFFFFF.  Now at this point, it becomes common math.

This is the breakdown of how many operations will be happening per second in total across all cores.


Operations / Second / Thread = 1,000,000,000

Threads = 100

Operations / Second = 1,000,000,000 * 100 = 100,000,000,000

Now let’s apply it to the UInt64.MaxValue.

Seconds / Operation = 1 / 100,000,000,000

Total Seconds = Operations * (Seconds / Operation) = 18446744073709551615 * (1 / 100,000,000,000) = ~184467441

Minutes = 184467441/ 60 = 3074457

Hours = 3074457 / 60 = 51241

Days = 51241 / 24 = 2135

Weeks = 2135 / 7 = 305

Years = 305 / 52 = 5.86

The discussion and point that came out of this is a feature that was introduced in .Net 4.  It’s the concept of parallelizing your loops across all available processors with the Parallel.For<> loop. This will have its obvious benefits of being able to process at n times the amount of processors that are available.


Friends

Alpha 46 Studios - Custom Web Design
Developer Memes : Hilarious!
Mr. D's Carpet Cleaning In Arizona
Alienware Fx Themes

StackOverflow Profile

profile for Adam at Stack Overflow, Q&A for professional and enthusiast programmers