Automatic ListView Grouping

Lets say you have lots of data your listview. Now you want to Group This data According to a Particular Subitem.

For Example:

Suppose i have some books data in my ListView.
this listview items contains Author name and Books Title.

And there are 2000 Books in list view.

Now i want to group the data in listview according to the Authors.

Now lets say there are 50 Unique Authors , meaning we will have to create 50 Groups in listview.

this seem hectic, and i don’t know if there is any inbuilt function to automatically group this items, but i have created mine To automatically do the above.

Hope it becomes useful to someone.

public void GroupListView(ListView lstV, int SubItemIndex) {
 bool flag = true;

 foreach(ListViewItem l in lstV.Items) {
  string strmyGroupname = l.SubItems[SubItemIndex].Text;

  foreach(ListViewGroup lvg in lstV.Groups) {
   if (lvg.Name == strmyGroupname) {
    l.Group = lvg;
    flag = false;
   }
  }

  if (flag == true) {
   ListViewGroup lstGrp = new ListViewGroup(strmyGroupname, strmyGroupname);
   lstV.Groups.Add(lstGrp);
   l.Group = lstGrp;
  }

  flag = true;
 }
}

How To Use The Code:
Lets say the author’s sub item’s index is 1 and listview name is LstBooks then call the function like:

GroupListView(LstBooks,1);

Vb.net Version:

Public Sub GroupListView(ByVal lstV As ListView, ByVal SubItemIndex As Int16)
Dim flag As Boolean = True
For Each l As ListViewItem In lstV.Items

Dim strmyGroupname As String = l.SubItems(SubItemIndex).Text

For Each lvg As ListViewGroup In lstV.Groups

If lvg.Name = strmyGroupname Then
l.Group = lvg
flag = False
End If

Next

If flag = True Then
Dim lstGrp As New ListViewGroup(strmyGroupname, strmyGroupname)
lstV.Groups.Add(lstGrp)
l.Group = lstGrp
End If

flag = True

Next
End Sub

Output:

listgroup

 

Auto Increment Invoice Number For Vb.net

Let’s say you have some invoice numbers which contains Alphabets as well as numeric number.
And you want to increment it one by one.
For Example:

if Invoice number is “AZ99999999” then Next Invoice Number will be “BA00000001”

Notice here that , the invoice number’s length is 10 Characters out of which first 2 are Alphabets and the rest (8) are Numeric. invoice number can be of any digit with any combination of numeric and alphabets.

The function can be changed to your need very easily. but here i will demonstrate for the above example.

Function:

Public Function IncrementInvoice(ByVal strInvoiceNumber As String) As String

If strInvoiceNumber.Length <> 10 Then
Return "Error"
End If

Dim strAlphaPart(1) As Char
strAlphaPart(0) = strInvoiceNumber(0)
strAlphaPart(1) = strInvoiceNumber(1)

Dim IntPart As Int64
IntPart = strInvoiceNumber.Substring(2, 8)
If IntPart = 99999999 Then
If strAlphaPart(1) = "Z" Then
strAlphaPart(0) = Chr(Asc(strAlphaPart(0)) + 1)
strAlphaPart(1) = "A"

IntPart = 1

Return strAlphaPart(0) & strAlphaPart(1) & IntPart.ToString.PadLeft(8, "0")
Else
strAlphaPart(1) = Chr(Asc(strAlphaPart(1)) + 1)
End If

Else
IntPart += 1
Return strAlphaPart(0) & strAlphaPart(1) & IntPart.ToString.PadLeft(8, "0")
End If

End Function

Output:

‘outputs example:
strTemp = IncrementInvoice(“AA99999998”) ‘Output will be: “AA99999999”
strTemp = IncrementInvoice(“AA00000005”) ‘Output will be: “AA00000006”
strTemp = IncrementInvoice(“AZ00000007”) ‘Output will be: “AZ00000008”
strTemp = IncrementInvoice(“AZ99999999”) ‘Output will be: “BA00000001”

 

A simple Class for Moving Controls At Runtime

Here Is The Class:

using System;
using System.Drawing;
using System.Windows.Forms;

namespace MoveControl
{
sealed class clsMoveControl
{
public enum Direction
{
Any,
Horizontal,
Vertical
}

public static void StartMoving(Control cntrl)
{
StartMoving(cntrl, Direction.Any);
}

public static void StartMoving(Control cntrl, Direction dir)
{
StartMoving(cntrl, cntrl, dir);
}

public static void StartMoving(Control cntrl, Control container, Direction dir)
{
bool Dragging = false;
Point DragStart = Point.Empty;
cntrl.MouseDown += delegate(object sender, MouseEventArgs e)
{
Dragging = true;
DragStart = new Point(e.X, e.Y);
cntrl.Capture = true;
};
cntrl.MouseUp += delegate(object sender, MouseEventArgs e)
{
Dragging = false;
cntrl.Capture = false;
};
cntrl.MouseMove += delegate(object sender, MouseEventArgs e)
{
if (Dragging)
{
if (dir != Direction.Vertical)
container.Left = Math.Max(0, e.X + container.Left - DragStart.X);
if (dir != Direction.Horizontal)
container.Top = Math.Max(0, e.Y + container.Top - DragStart.Y);
}
};
}
}
}


How to Use Example :

1. Create a simple project .
2. On the load event of the form write the following coding

clsMoveControl.StartMoving(this);

This will make the form movable by clicking anywhare on the form and dragging it.
The same can be done for other controls like:

clsMoveControl.StartMoving(Button1);
clsMoveControl.StartMoving(Panel1);

See it Live:


 

Trimming a String Arrary

Let’s Say i have following array:

string[] myArray = new string[6];
myArray[0] = "a";
myArray[1] = "b";
myArray[2] = " "; //space
myArray[3] = "c";
myArray[4] = ""; //null
myArray[5] = "d";

I want to remove the space and null parts from the array.
so after trimming the array should be like this:

            myArray[0] = "a";
myArray[1] = "b";
myArray[2] = "c";
myArray[3] = "d";

Code:

public string[] TrimStringArray(string[] strArray)
{

int c = 0;
foreach (string str in strArray)
{
if (str != "" && str != null)
{
c++;
}
}

string[] tempArrary = new string;
int j=0;
for (int i = 0; i < strArray.Length; i++)
{
if( strArray[i] != null && strArray[i] != "")
{
tempArrary[j] = strArray[i];
j++;
}
}

return tempArrary;
}

Examle:

myArray = TrimStringArray(myArray);
 

.Net Framework 3.0 Vs 3.5 Vs 4.0 (.Net FrameWork Comparisions)

NET Framework 3.0 consists of four major new components:

  • Windows Presentation Foundation (WPF), formerly code-named Avalon; a new user interface subsystem and API based on XML and vector graphics, which uses 3D computer graphics hardware and Direct3D technologies. See WPF SDK for developer articles and documentation on WPF.
  • Windows Communication Foundation (WCF), formerly code-named Indigo; a service-oriented messaging system which allows programs to interoperate locally or remotely similar to web services.
  • Windows Workflow Foundation (WF) allows for building of task automation and integrated transactions using workflows.
  • Windows CardSpace, formerly code-named InfoCard; a software component which securely stores a person’s digital identities and provides a unified interface for choosing the identity for a particular transaction, such as logging in to a website.

Changes in 3.5 since 3.0

  • New language features in C# 3.0 and VB.NET 9.0 compiler
  • Adds support for expression trees and lambda methods
  • Extension methods
  • Expression trees to represent high-level source code at runtime.
  • Anonymous types with static type inference
  • Language Integrated Query (LINQ) along with its various providers
  • LINQ to Objects
  • LINQ to XML
  • LINQ to SQL
  • Paging support for ADO.NET
  • ADO.NET synchronization API to synchronize local caches and server side datastores
  • Asynchronous network I/O API.
  • Peer-to-peer networking stack, including a managed PNRP resolver
  • Managed wrappers for Windows Management Instrumentation and Active Directory APIs
  • Enhanced WCF and WF runtimes, which let WCF work with POX and JSON data, and also expose WF workflows as WCF services. WCF services can be made stateful using the WF persistence model.
  • Support for HTTP pipelining and syndication feeds.
  • ASP.NET AJAX is included.

Key focuses for 4.0  release are:

  • Parallel Extensions to improve support for parallel computing, which target multi-core or distributed systems. To this end, technologies like PLINQ (Parallel LINQ), a parallel implementation of the LINQ engine, and Task Parallel Library, which exposes parallel constructs via method calls., are included.
  • New Visual Basic .NET and C# language features, such as statement lambdas, implicit line continuations, dynamic dispatch, named parameters, and optional parameters.
  • Support for Code Contracts.
  • Inclusion of new types to work with arbitrary-precision arithmetic (System.Numerics.BigInteger) and complex numbers (System.Numerics.Complex).

Source: wikipedia.org

 

A Function to Concat String Array Values by Specified Delimiter

Let ‘s Say I have Following Array:

string[] st = new string[5];
st[0] = "Animation";
st[1] = "Action";
st[2] = "Romance";
st[3] = "Drame";
st[4] = "Comedy";

Now I want to Merge all of it with ‘,’ Delimiter Like Below:

Output :   Animation,Action,Romance,Drame,Comedy

Here is the Function For the Above

public string GetAllStringsFromArrary(string[] strArray,string strDelimeter)
{
string strFinal = string.Empty;

for (int i = 0; i < strArray.Length ; i++)
{
strFinal += strArray[i];

if (i != strArray.Length - 1)
{
strFinal += strDelimeter;
}
}
return strFinal;


}

We will Call it Like This:

string str = GetAllStringsFromArrary( st,",");
 

A Function to find strings Between a Given Word/string

For example :
let’s say you have following Text:

Title                    Author              Product*         
~~~~~ ~~~~~~ ~~~~~~~~
"Aurora's Eggs" Douglas Niles Story (Dragons 2)

The Dragons Douglas Niles Novel

The Kinslayer Wars Douglas Niles Novel

The Qualinesti Paul B. Thompson Novel
& Tonya C. Cook

Vinas Solamnus J. Robert King Novel

The Dargonesti Paul B. Thompson Novel
& Tonya C. Cook

"Storytellers" Nick O'Donohoe Story (Dragons 2)

"The Best" Margaret Weis Story (Dragons 1)

"Quarry" Adam Lesh Story (Dragons 2)

"Easy Pickings" Douglas Niles Story (Dragons 1)

The Legend of Huma Richard A. Knaak Novel

And I want to find Everthing that is in between ” character.

The Answer should be like Following

Aurora's Eggs

Storytellers

The Best

Quarry

Easy Pickings

For this use the following Function:

public static List FindStringBetween(string strData,string strFindWhat)
{
List lstFound = new List();
int startIndex, EndIndex;
startIndex = strData.IndexOf(strFindWhat);

EndIndex = strData.IndexOf(strFindWhat, startIndex + strFindWhat.Length);

if (EndIndex > 0)
{
lstFound.Add(strData.Substring(startIndex+strFindWhat.Length ,EndIndex - startIndex-strFindWhat.Length ));
}

while (EndIndex > 0)
{
startIndex = strData.IndexOf(strFindWhat, EndIndex + 1);
if (startIndex == -1) {
return lstFound; }
EndIndex = strData.IndexOf(strFindWhat, startIndex + 1);
if (EndIndex > 0)
{
lstFound.Add(strData.Substring(startIndex + strFindWhat.Length, EndIndex - startIndex - strFindWhat.Length));
}
}

return lstFound;
}

Please ignore the last line.

It will give you the complete list of the strings found.

 
%d bloggers like this: