1
2-- set options
3SET NOCOUNT ON;
4SET ANSI_PADDING ON;
5SET ANSI_NULLS ON;
6SET QUOTED_IDENTIFIER ON;
7
8
9-- declare table to store table names
10-- in SQL 2005 you can use table variables
11-- if you do not need or want to store the data you can store it in a table
12-- variable instead of a temporary table
13DECLARE @tablenames TABLE (
14 TableName VARCHAR(255)
15);
16
17
18
19-- populate table with tablenames
20INSERT INTO @tablenames
21 SELECT
22 name
23 FROM
24 sys.objects
25 -- additional filters can be set to narrow table selection
26 WHERE
27 ([type] = 'U');
28
29
30
31-- Declare a cursor to loop through table
32DECLARE tablenames INSENSITIVE SCROLL CURSOR
33 FOR
34 SELECT
35 TableName
36 FROM
37 @tablenames;
38
39
40
41
42-- Open the cursor.
43OPEN tablenames
44
45
46
47-- declare variables
48DECLARE @curtablename AS VARCHAR(255);
49DECLARE @cmd AS VARCHAR(1024);
50
51
52
53-- Loop through all the tables
54WHILE (1=1)
55 BEGIN
56 FETCH NEXT FROM tablenames INTO @curtablename;
57 IF @@fetch_status <> 0 BREAK;
58 -- run the command
59 set @cmd = 'DBCC CHECKTABLE ([' + rtrim(@curtablename) + '])';
60 exec (@cmd)
61 print @cmd + CHAR(10) + CHAR(13);
62 end
63
64
65
66-- Close cursor
67CLOSE tablenames;
68DEALLOCATE tablenames;
69

Labels: Code, SQL

1/**//** **/
2-- Create table to hold index information
3SET NOCOUNT ON;
4
5create table _IndexInformation (
6 database_id smallint,
7 ObjectName varchar(255),
8 [object_id] int,
9 IndexName varchar(255),
10 [index_id] int,
11 index_level int,
12 index_type_desc varchar(60),
13 avg_fragmentation_in_percent float,
14 fragment_count float,
15 page_count bigint,
16 record_count bigint,
17 index_depth int
18);
19/**//** **/

1/**//** **/
2-- clear table contents
3truncate table _IndexInformation;
4
5-- populate table
6insert into _IndexInformation
7 select
8 database_id,
9 object_name(i.object_id) AS [ObjectName],
10 i.[object_id],
11 i.name AS [IndexName],
12 dm.index_id,
13 dm.index_level,
14 dm.index_type_desc,
15 dm.avg_fragmentation_in_percent,
16 dm.fragment_count,
17 dm.page_count,
18 dm.record_count,
19 dm.index_depth
20 from
21 -- database, table and index information can be specified
22 /**//*
23 sys.dm_db_index_physical_stats (
24 { database_id NULL 0 DEFAULT }
25 , { object_id NULL 0 DEFAULT }
26 , { index_id NULL 0 -1 DEFAULT }
27 , { partition_number NULL 0 DEFAULT }
28 , { mode NULL DEFAULT }
29 )
29 This example uses database 1; you should replace this with the ID of the database you wish to process
30 */
31 sys.dm_db_index_physical_stats(1,null,null,null,'detailed') dm
32 INNER JOIN sys.indexes i ON
33 (i.object_id = dm.object_id) AND (i.index_id = dm.index_id);
34/**//** **/
35

1/**//** **/
2-- read index table and maintain indexes
3SET NOCOUNT ON;
4SET ANSI_PADDING ON;
5SET ANSI_NULLS ON;
6SET QUOTED_IDENTIFIER ON;
7
8
9-- Declare variables.
10declare @tablename as varchar(255)
11declare @indexname as varchar(255)
12declare @frag as float
13declare @cmd as varchar(1024)
14
15-- Declare a cursor.
16declare indexes insensitive scroll cursor
17for
18 select
19 ObjectName,
20 IndexName,
21 avg_fragmentation_in_percent
22 from
23 _IndexInformation
24 where
25 (avg_fragmentation_in_percent >= 5);
26
27-- Open the cursor.
28open indexes
29
30
31-- Loop through all the indexes.
32while (1=1)
33 begin
34 fetch next from indexes into @tablename, @indexname, @frag;
35 if @@fetch_status <> 0 break;
36 -- if fragmentation is above 30% rebuild index
37 -- if fragmentation is above 5% reorganize index
38 if (@frag >= 30)
39 begin
40 set @cmd = 'ALTER INDEX [' + rtrim(@indexname) + '] ON [' + @tablename +'] REBUILD;'
41 exec (@cmd)
42 print @cmd;
43 end
44 else
45 if (@frag >= 5)
46 begin
47 set @cmd = 'ALTER INDEX [' + rtrim(@indexname) + '] ON [' + @tablename +'] REORGANIZE;'
48 exec (@cmd)
49 print @cmd;
50 end;
51 end
52
53
54
55-- Close cursor
56close indexes;
57deallocate indexes;
58/**//** **/
59

1/**//** **/
2-- delete index table
3drop table _IndexInformation;
4/**//** **/
5

Labels: Code, SQL

1SELECT
2 database_id,
3 DB_Name(database_id) as database_name,
4 [file_id],
5 type_desc,
6 [name],
7 physical_name,
8 state_desc,
9 [size],
10 max_size
11FROM
12 sys.master_files
13WHERE
14 -- you can use the DB_ID function to return the
15 -- database id of a database by name
16 (database_id = DB_ID(N'master'))
17 -- if you know the id you can filter by it directly
18 -- (database_id = 1)
19ORDER BY
20 type_desc DESC,
21 physical_name;

1SELECT
2 database_id,
3 [name],
4 compatibility_level,
5 collation_name,
6 state_desc
7FROM
8 sys.databases;

Labels: Code, SQL

Labels: Code, How-To, SQL

The stored procedure is called like;

Labels: Code, How-To, SQL

Labels: Code, How-To, SQL

I am not going to get overly verbose here; however the importance of application logging is immeasurable. When applications are deployed, obtaining ‘real life’ application can assist in diagnostic and overall application health situations. Excessive logging can be ineffective (too much to analyze) and burdensome (logging to a text file that grows forever) if not implemented appropriately.

When developing and deploying an application having the flexibility of what, when and how to log can alleviate the burden and ineffectiveness of logging. The System.Diagnostics namespace has a number of classes available that allow for this type of flexible logging. The applied use of these classes allows a developer to specify what to log in an application at various levels of detail within one application without the need to deploy diagnostic builds. Depending on diagnostic needs, the application’s config file can specify the level of diagnostic information to write and where. A simple Logging class (this is the class I created to use this functionality) can be developed as follows:

1namespace BPSoftware
2...{
3 public class Logging
4 ...{
5 /**//// <summary>
6 /// strNameSpace is the base namespace for use in the logging message.
7 /// </summary>
8 public static string strNameSpace;
9
10 /**//// <summary>
11 /// GeneralTraceSwitch is a traceswitch object for logging. Switch level is set through
12 /// the application config switches section. The destination listener is also set through
13 /// the application config file.
14 /// </summary>
15 public static TraceSwitch GeneralTraceSwitch = new TraceSwitch( "General", "General Trace Switch" );
16
17 Methods#region Methods
18 /**//// <summary>
19 /// Writeline is the base logging method. Messages are logged to the listener specified
20 /// in the application config file.
21 /// </summary>
22 /// <param name="strClassName">Calling class name.</param>
23 /// <param name="strMethodName">Calling method name.</param>
24 /// <param name="strMessage">The message sent to the listener.</param>
25 public static void WriteLine( string strClassName, string strMethodName, string strMessage )
26 ...{
27 lock ( typeof( Logging ) )
28 ...{
29 Trace.WriteLine( string.Concat(
30 new object[] ...{
31 "(", DateTime.Now, ") ",
32 strNameSpace, ".", strClassName, ".", strMethodName, " -->", strMessage
33 }
34 ) );
35 }
36 }
37
38 /**//// <summary>
39 /// Pass information to the base WriteLine if the TraceError switch is set.
40 /// </summary>
41 /// <param name="strClassName">Calling class name.</param>
42 /// <param name="strMethodName">Calling method name.</param>
43 /// <param name="strMessage">The message sent to the listener.</param>
44 public static void WriteLineTraceError( string strClassName, string strMethodName, string strMessage )
45 ...{
46 if ( Logging.GeneralTraceSwitch.TraceError )
47 WriteLine( strClassName, strMethodName, strMessage );
48 }
49
50 /**//// <summary>
51 /// Pass information to the base WriteLine if the TraceWarning switch is set.
52 /// </summary>
53 /// <param name="strClassName">Calling class name.</param>
54 /// <param name="strMethodName">Calling method name.</param>
55 /// <param name="strMessage">The message sent to the listener.</param>
56 public static void WriteLineTraceWarning( string strClassName, string strMethodName, string strMessage )
57 ...{
58 if ( Logging.GeneralTraceSwitch.TraceWarning )
59 WriteLine( strClassName, strMethodName, strMessage );
60 }
61
62 /**//// <summary>
63 /// Pass information to the base WriteLine if the TraceInfo switch is set.
64 /// </summary>
65 /// <param name="strClassName">Calling class name.</param>
66 /// <param name="strMethodName">Calling method name.</param>
67 /// <param name="strMessage">The message sent to the listener.</param>
68 public static void WriteLineTraceInfo( string strClassName, string strMethodName, string strMessage )
69 ...{
70 if ( Logging.GeneralTraceSwitch.TraceInfo )
71 WriteLine( strClassName, strMethodName, strMessage );
72 }
73
74 /**//// <summary>
75 /// Pass information to the base WriteLine if the TraceVerbose switch is set.
76 /// </summary>
77 /// <param name="strClassName">Calling class name.</param>
78 /// <param name="strMethodName">Calling method name.</param>
79 /// <param name="strMessage">The message sent to the listener.</param>
80 public static void WriteLineTraceVerbose( string strClassName, string strMethodName, string strMessage )
81 ...{
82 if ( Logging.GeneralTraceSwitch.TraceVerbose )
83 WriteLine( strClassName, strMethodName, strMessage );
84 }
85 #endregion
86 }
87}

1 catch ( Exception ex)
2 ...{
3 Logging.WriteLineTraceError( "ClassName", "Method", "Exception: " + ex.Message );
4 }
5
6 Logging.WriteLineTraceInfo( "ClassName", "Method",,
7 String.Format( "{0}: {1}", e.ActionType.ToString(), e.Message )
8 );

1 <system.diagnostics>
2 <trace autoflush="true" indentsize="4">
3 <!-- Specify listener output -->
4 <listeners>
5 <remove name="Default" />
6 <!-- Write to a log file -->
7 <add name="Default"
8 type="System.Diagnostics.TextWriterTraceListener"
9 initializeData="AFileSync.log" />
10 <!-- Write to the Event Log-->
11 <!-- <add name="Default"
12 type="System.Diagnostics.EventLogTraceListener"
13 initializeData="Application" /> -->
14 </listeners>
15 </trace>
16 <switches>
17 <!-- Off = 0, Error = 1, Warning = 2, Info = 3, Verbose = 4 -->
18 <add name="General" value="3" />
19 </switches>
20 </system.diagnostics>

Labels: .NET, C#, Code, How-To

As I whipped up my file synchronizing service application, to synchronize files between my computer and my NAS), I worked with the System.ServiceProcess Namespace. The System.ServiceProcess Namespace "provides classes that allow you to implement, install, and control Windows service applications".

My file synchronization needs did not require that my application service to be "running" all the time. In, fact I only needed the service to run under certain situations. It was easy enough to get the service written and installed and now I wanted to 'automatically' (programmatically) start and stop my service when certain conditions were met.

Entrance - the ServiceController Class. The ServiceController Class "Represents a Windows service and allows you to connect to a running or stopped service, manipulate it, or get information about it." In order to get acclimated to the ServiceController Class I created a simple application to list and display information about the installed services.

1using System;
2using System.Windows.Forms;
3using System.ServiceProcess;
4
5namespace Services1
6...{
7 public partial class Form1 : Form
8 ...{
9 ServiceController controller;
10
11 public Form1()
12 ...{
13 controller = new ServiceController();
14 controller.MachineName = ".";
15 InitializeComponent();
16 lstServices.DisplayMember = "DisplayName";
17 lstServices.ValueMember = "ServiceName";
18 lstServices.DataSource = ServiceController.GetServices();
19 }
20
21 private void StartService(string servicename)
22 ...{
23 controller.ServiceName = servicename;
24 controller.Start();
25
26 }
27
28 private void PauseService(string servicename)
29 ...{
30 controller.ServiceName = servicename;
31 if (controller.CanPauseAndContinue)
32 controller.Pause();
33 }
34
35 private void StopService(string servicename)
36 ...{
37 controller.ServiceName = servicename;
38 if (controller.CanStop)
39 controller.Stop();
40 }
41
42
43 private void listBox1_SelectedIndexChanged(object sender, EventArgs e)
44 ...{
45 if (lstServices.SelectedItems.Count > 0)
46 ...{
47 try
48 ...{
49 controller.ServiceName = lstServices.SelectedValue.ToString();
50 textBox1.Text = String.Format(
51 "Service Name: {0}\r\nDisplay Name: {1}\r\nType: {2}\r\nStatus: {3}",
52 controller.ServiceName,
53 controller.DisplayName,
54 controller.ServiceType.ToString(),
55 controller.Status.ToString()
56 );
57 }
58 catch (Exception ex)
59 ...{
60 textBox1.Text = String.Format("Error: \r\n{0}",ex.Message);
61 }
62 }
63 else
64 ...{
65 textBox1.Clear();
66 }
67 }
68
69 private void btnStart_Click(object sender, EventArgs e)
70 ...{
71 StartService(lstServices.SelectedValue.ToString());
72 }
73
74 private void btnPause_Click(object sender, EventArgs e)
75 ...{
76 PauseService(lstServices.SelectedValue.ToString());
77 }
78
79 private void btnStop_Click(object sender, EventArgs e)
80 ...{
81 StopService(lstServices.SelectedValue.ToString());
82 }
83 }
84}

Labels: .NET, C#, Code

Recently, I posted about the new addition to my backup strategy; a NAS. My intended use of this device is to have a hot backup of my files. The system I was using before was not capable of storing the amount of data I need backed up, nor was it easy to manage. I modified the set of xCopy batch files that I used for my backups to write the files to the NAS.

This system worked fine, but I needed more. I manage a lot of data and have a lot of files. I wouldn't want to lose any in the event of a system failure. The one problem I see with using this process is the lack of a real time solution.

I was in search of a solution that would offer me real-time synchronization between my files and the NAS. I didn't have to search very far. The .NET Framework includes the FileSystemWatcher Class.

The FileSystemWatcher Class "Listens to the file system change notifications and raises events when a directory, or file in a directory, changes." (quoted directly from MSDN) After reading through this class I quickly whipped up a solution. I developed my own FileSync class that allowed me to easily synchronize files between my remote and local storage. I created a Windows Service (threaded) built around my class (the screen shot in this post is from a sample app I used to test my class) so that I could have the FileSync class running and keeping my files in sync without me needing to do anything. Here is the unit I created:

1using System;
2using System.IO;
3using System.Diagnostics;
4
5namespace BPSoftware
6...{
7 class FileSync
8 ...{
9 private FileSystemWatcher watcher;
10
11 Fields#region Fields
12 private string destpath;
13 public string DestPath
14 ...{
15 get ...{ return destpath; }
16 set ...{ destpath = value; }
17 }
18
19 private string sourcepath;
20 public string SourcePath
21 ...{
22 get ...{ return sourcepath; }
23 set ...{ sourcepath = value; }
24 }
25
26 private string filter;
27 public string Filter
28 ...{
29 get ...{ return filter; }
30 set ...{ filter = value; }
31 }
32
33 private bool watchsubfolders;
34 public bool WatchSubFolders
35 ...{
36 get ...{ return watchsubfolders; }
37 set ...{ watchsubfolders = value; }
38 }
39 #endregion
40
41 Constructors#region Constructors
42 public FileSync()
43 ...{
44 this.watcher = new FileSystemWatcher();
45 this.watcher.InternalBufferSize = 0x20000;
46 this.watcher.NotifyFilter = NotifyFilters.FileNameNotifyFilters.LastWrite;
47 this.watcher.IncludeSubdirectories = false;
48 this.watcher.Changed += new FileSystemEventHandler(this.OnChanged);
49 this.watcher.Created += new FileSystemEventHandler(this.OnCreated);
50 this.watcher.Deleted += new FileSystemEventHandler(this.OnDeleted);
51 this.watcher.Renamed += new RenamedEventHandler(this.OnRenamed);
52 }
53
54 public FileSync(string source, string destination, string filefilter, bool watchsubs): this()
55 ...{
56 this.SourcePath = source;
57 this.DestPath = destination;
58 this.Filter = filefilter;
59 this.WatchSubFolders = watchsubs;
60 }
61 #endregion
62
63 Methods#region Methods
64 private string GetDestinationFile(string infile)
65 ...{
66 string fileName = Path.GetFileName(infile);
67 return (this.destpath + fileName);
68 }
69
70 private void LogEvent(string message, int id)
71 ...{
72 EventLog.WriteEntry("FileSync", message, EventLogEntryType.Error, id);
73 }
74
75 public void Start()
76 ...{
77 try
78 ...{
79 if (this.watcher != null)
80 ...{
81 this.watcher.Path = this.SourcePath;
82 this.watcher.Filter = this.Filter;
83 this.watcher.IncludeSubdirectories = this.WatchSubFolders;
84 this.watcher.Filter = this.Filter;
85 this.watcher.EnableRaisingEvents = true;
86 }
87 }
88 catch (Exception exception)
89 ...{
90 this.LogEvent(exception.Message, 0x01);
91 }
92 }
93
94 public bool Stop()
95 ...{
96 try
97 ...{
98 if (this.watcher != null)
99 ...{
100 this.watcher.EnableRaisingEvents = false;
101 this.watcher.Changed -= new FileSystemEventHandler(this.OnChanged);
102 this.watcher.Created -= new FileSystemEventHandler(this.OnCreated);
103 this.watcher.Deleted -= new FileSystemEventHandler(this.OnDeleted);
104 this.watcher.Renamed -= new RenamedEventHandler(this.OnRenamed);
105 }
106 }
107 catch (Exception exception)
108 ...{
109 this.LogEvent(exception.Message, 0x02);
110 return false;
111 }
112 return true;
113 }
114 #endregion
115
116 Events#region Events
117 private void OnChanged(object source, FileSystemEventArgs e)
118 ...{
119 try
120 ...{
121 File.Copy(e.FullPath, this.GetDestinationFile(e.FullPath), true);
122 }
123 catch (Exception exception)
124 ...{
125 this.LogEvent(exception.Message, 0x03);
126 }
127 }
128
129 private void OnCreated(object source, FileSystemEventArgs e)
130 ...{
131 try
132 ...{
133 File.Copy(e.FullPath, this.GetDestinationFile(e.FullPath));
134 }
135 catch (Exception exception)
136 ...{
137 this.LogEvent(exception.Message, 0x04);
138 }
139 }
140
141 private void OnDeleted(object source, FileSystemEventArgs e)
142 ...{
143 try
144 ...{
145 File.Delete(this.GetDestinationFile(e.FullPath));
146 }
147 catch (Exception exception)
148 ...{
149 this.LogEvent(exception.Message, 0x05);
150 }
151 }
152
153 private void OnRenamed(object source, RenamedEventArgs e)
154 ...{
155 try
156 ...{
157 File.Move(this.GetDestinationFile(e.OldFullPath), this.GetDestinationFile(e.FullPath));
158 }
159 catch (Exception exception)
160 ...{
161 this.LogEvent(exception.Message, 0x06);
162 }
163 }
164 #endregion
165 }
166}
167

Labels: .NET, C#, Code

Yesterday I posted about using ShellExecuteEx to display the document properties dialog for a file or folder. Displaying the properties dialog is nice, however I also need to access the OLE document properties (Document Summary Properties), the information that is stored on the Summary and Custom tabs of the properties dialog. I did quite a bit of searching, reading and testing in an attempt to find a simple solution. I did get to learn a lot about the Document Summary Properties and it looked like my only option was to head down the road using the IPropertyStorage Interface. As I was testing some code I came across the best little ActiveX component that can quickly access the property information. The Dsofile.dll is an ActiveX component is available from Microsoft. They even include a sample application (although the samples are in VB6 and VB7 they are useable). This component simplifies (I like things simple) setting and getting the document summary properties. The KB article and download mention that this is meant for Office files, however I have found that it works fine on other files as well (the exception being that the Office documents seem to be the only types of files with Custom Properties). The other great thing about this component is that "You have a royalty-free right to use, to modify, to reproduce, and to distribute the Dsofile.dll sample file component and the C++ source code files in any way you find useful." That quote is taken directly from the DSOfile.dll Article ID: 224351 that is listed on Microsoft's Support site. My thoughts, why reinvent the wheel when you really don't need to. I highly recommend using this component if you need to access the extended properties. As usual, I whipped up a sample application testing this components functionality. The meager sample code is listed here (image of application screen is also included in this post):

1 public partial class Form1 : Form
2 ...{
3 public Form1()
4 ...{
5 InitializeComponent();
6 }
7
8 private void btnSelectFile_Click(object sender, EventArgs e)
9 ...{
10 if (openFileDialog1.ShowDialog() == DialogResult.OK)
11 ...{
12 textBox1.Text = openFileDialog1.FileName;
13 toolTip1.SetToolTip(textBox1, textBox1.Text);
14 lstSummary.Items.Clear();
15
16 OleDocumentPropertiesClass odpc = new OleDocumentPropertiesClass();
17 odpc.Open(
18 @openFileDialog1.FileName,
19 false,
20 dsoFileOpenOptions.dsoOptionOpenReadOnlyIfNoWriteAccess
21 );
22 // Summary "Standard" Properties
23 ListViewItem lvTitle = new ListViewItem();
24 lvTitle.Group = lstSummary.Groups[0];
25 lvTitle.Text = "Title";
26 lvTitle.SubItems.Add(odpc.SummaryProperties.Title);
27 lstSummary.Items.Add(lvTitle);
28
29 ListViewItem lvSubject = new ListViewItem();
30 lvSubject.Group = lstSummary.Groups[0];
31 lvSubject.Text = "Subject";
32 lvSubject.SubItems.Add(odpc.SummaryProperties.Subject);
33 lstSummary.Items.Add(lvSubject);
34
35 ListViewItem lvCategory = new ListViewItem();
36 lvCategory.Group = lstSummary.Groups[0];
37 lvCategory.Text = "Category";
38 lvCategory.SubItems.Add(odpc.SummaryProperties.Category);
39 lstSummary.Items.Add(lvCategory);
40
41 ListViewItem lvKeyword = new ListViewItem();
42 lvKeyword.Group = lstSummary.Groups[0];
43 lvKeyword.Text = "Keywords";
44 lvKeyword.SubItems.Add(odpc.SummaryProperties.Keywords);
45 lstSummary.Items.Add(lvKeyword);
46
47 ListViewItem lvComments = new ListViewItem();
48 lvComments.Group = lstSummary.Groups[0];
49 lvComments.Text = "Comments";
50 lvComments.SubItems.Add(odpc.SummaryProperties.Comments);
51 lstSummary.Items.Add(lvComments);
52
53 ListViewItem lvAuthor = new ListViewItem();
54 lvAuthor.Group = lstSummary.Groups[1];
55 lvAuthor.Text = "Author";
56 lvAuthor.SubItems.Add(odpc.SummaryProperties.Author);
57 lstSummary.Items.Add(lvAuthor);
58
59 ListViewItem lvRevision = new ListViewItem();
60 lvRevision.Group = lstSummary.Groups[1];
61 lvRevision.Text = "Revision Number";
62 lvRevision.SubItems.Add(odpc.SummaryProperties.RevisionNumber);
63 lstSummary.Items.Add(lvRevision);
64
65 // Custom Properties
66 foreach (DSOFile.CustomProperty cp in odpc.CustomProperties)
67 ...{
68 ListViewItem lvc = new ListViewItem();
69 lvc.Group = lstSummary.Groups[2];
70 lvc.Text=cp.Name;
71 lvc.SubItems.Add(cp.get_Value().ToString());
72 lstSummary.Items.Add(lvc);
73 }
74 odpc.Close(false);
75 }
76 }
77 }

This is something I'd also like to port to Delphi for use in those applications. Maybe this week sometime......

Labels: .NET, C#, Code

Who says history doesn't repeat itself? I am working on a project that needs to display and access file properties. A quick search through the .NET 2.0 Framework didn't yield anything that popped out. I did however, remember our wonderful friend - the SHELL32 API. Previously, I had posted on using ShellExecuteEX with Delphi (I am a huge Delphi fan; I may not be posting much about it recently, but I did not forget it). Here is that same sample in using C#.

1 public const uint SW_SHOW =0x5;
2 public const uint SEE_MASK_INVOKEIDLIST = 0xC;
3
4 public enum verbs
5 ...{
6 properties,
7 open,
8 edit,
9 explore,
10 print
11 }
12
13 [StructLayout(LayoutKind.Sequential)]
14 public struct SHELLEXECUTEINFO
15 ...{
16 public int cbSize;
17 public uint fMask;
18 public IntPtr hwnd;
19 public String lpVerb;
20 public String lpFile;
21 public String lpParameters;
22 public String lpDirectory;
23 public uint nShow;
24 public int hInstApp;
25 public int lpIDList;
26 public String lpClass;
27 public int hkeyClass;
28 public uint dwHotKey;
29 public int hIcon;
30 public int hProcess;
31 }
32
33 [DllImport("shell32.dll")]
34 static extern bool ShellExecuteEx(ref SHELLEXECUTEINFO lpExecInfo);
35
36 public void MyShellExecuteInfo(string filename, verbs verb)
37 ...{
38 SHELLEXECUTEINFO info = new SHELLEXECUTEINFO();
39 info.cbSize = System.Runtime.InteropServices.Marshal.SizeOf(info);
40 switch (verb)
41 ...{
42 case verbs.properties:
43 info.lpVerb = "properties";
44 break;
45 case verbs.print:
46 info.lpVerb = "print";
47 break;
48 case verbs.open:
49 info.lpVerb = "open";
50 break;
51 case verbs.explore:
52 info.lpVerb = "explore";
53 break;
54 case verbs.edit:
55 info.lpVerb = "edit";
56 break;
57 }
58
59 info.lpFile = filename;
60 info.nShow = SW_SHOW;
61 info.fMask = SEE_MASK_INVOKEIDLIST;
62 ShellExecuteEx(ref info);
63 }
64

Labels: .NET, C#, Code

One nice addition to the .NET 2.0 framework is the ToolStripMenuItem Class. The ToolStripMenuItem Class replaces the MenuItem Class. The ToolStripMenuItem has a Checked property that gets or sets a value indicating if the item is checked or not. Coupled with the ToolStripMenuItem.CheckOnClick property, this can be useful for identifying which item has been selected or activated. Unfortunately, there isn't some sort of 'allow only one checked' property which allows for only one item in a menu to be 'Checked' at a time. This functionality can be easily added in code (or you could derive your own class that has this functionality; a nice addition to a personal control library). Create an OnClick and OnCheckChanged method that are referenced by each of the ToolStripMenuItems. Basically, you check to see if the current item is checked or not and then toggle the check for the other menu items. You could also check another property of the sender (such as the Tag property) to perform some other action.

Here is an example:

1 private void CheckedIconsToolStripMenuItem_CheckedChanged(object sender, EventArgs e)
2 ...{
3 if (sender is ToolStripMenuItem)
4 ...{
5 if (!((ToolStripMenuItem)sender).Checked) return;
6 foreach (ToolStripMenuItem item in (((ToolStripMenuItem)sender).GetCurrentParent().Items))
7 ...{
8 if (item != null && item != sender && item.Checked)
9 ...{
10 item.Checked = false;
11 return;
12 }
13 }
14 }
15 }
16
17 private void CheckedToolStripMenuItem_Click(object sender, EventArgs e)
18 ...{
19 if (sender is System.Windows.Forms.ToolStripMenuItem)
20 ...{
21 if (!((ToolStripMenuItem)sender).Checked)
22 ...{
23 ((ToolStripMenuItem)sender).Checked = !((ToolStripMenuItem)sender).Checked;
24 };
25 switch (((ToolStripMenuItem)sender).Tag.ToString())
26 ...{
27 case "1":
28 break;
29 case "2":
30 break;
31 case "3":
32 break;
33 case "4":
34 break;
35 case "5":
36 break;
37 default:
38 break;
39 };
40 }
41 }
42

Labels: .NET, C#, Code

I can hear the theme for Welcome Back Kotter as I write this. It seems that things have been quiet on here for quite sometime, however those that know me can attest to the fact that life away from here has been anything but that. Thankfully, things have returned to a point where a lot more content should find its way onto this world.

As things progress, I am doing a substantial amount of development using C# and the .NET Framework. I still continue to develop new utilities that satisfy my specific needs. I also try to update some of the available utilities. The most recent update has been to ASysIcon (this application was redeveloped using the .NET Framework). I've done quite a bit of work with icons in the past (also take a look at AIconExtract) and ASysIcon is a utility that displays the images found in the system image list. The system image list contains the icons that are associated with the different registered file types on a computer.

The retrieval of the system image list is a straight forward process. There are a few unmanaged API calls that work quite well for this task. One thing that may not be so apparent is that the the images retrieved will be those images that are cached in the system image list. If the system hasn't had a need to load them, well, they won't be in the list. This could pose some concern if you would like to retrieve the entire list. The trick is to get all the system images cached. Actually, this isn't really a trick. With little searching the FileIconInit function surfaces. This function will initialize or reinitialize this image list. FileIconInit has a boolean parameter determines if it should restore the image cache from disk. Passing true as this parameter will load all of the images, not just the recently cached ones. The following sample code shows how to display the system image list in a ListView:

1using System;
2using System.Windows.Forms;
3
4 using System.Runtime.InteropServices; // http://support.microsoft.com/kb/319350
5
6namespace SysIcons1
7...{
8 public partial class Form1 : Form
9 ...{
10 [StructLayout(LayoutKind.Sequential)]
11 public struct SHFILEINFO
12 ...{
13 public IntPtr hIcon;
14 public IntPtr iIcon;
15 public uint dwAttributes;
16 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
17 public string szDisplayName;
18 [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
19 public string szTypeName;
20 };
21 //Retrieve the handle to the icon that represents the file and the index of the icon within the system image list
22 public const uint SHGFI_ICON = 0x100;
23
24 // Retrieve the index of a system image list icon.
25 public const uint SHGFI_SYSICONINDEX = 0x4000;
26
27 // Large icon
28 public const uint SHGFI_LARGEICON = 0x0;
29
30 // Small icon
31 public const uint SHGFI_SMALLICON = 0x1;
32
33 public const uint LVM_FIRST = 4096;
34 public const uint LVSIL_NORMAL = 0;
35 public const uint LVSIL_SMALL = 1;
36 public const uint LVM_SETIMAGELIST = LVM_FIRST + 3;
37 // need this style on Windows 9x
38 public const uint LVS_SHAREIMAGELISTS = 0x0040;
39
40 // Retrieves information about an object in the file system, such as a file, folder, directory, or drive root.
41 [DllImport("shell32.dll")]
42 public static extern IntPtr SHGetFileInfo(string pszPath, uint dwFileAttributes, ref SHFILEINFO psfi, uint cbSizeFileInfo, uint uFlags);
43
44 // The SendMessage function sends the specified message to a window or windows.
45 [DllImport("user32.dll")]
46 private static extern UInt32 SendMessage(IntPtr hWnd, UInt32 Msg,
47 UInt32 wParam, UInt32 lParam);
48
49 // Destroys an icon and frees any memory the icon occupied.
50 [DllImport("User32.dll")]
51 private static extern int DestroyIcon(System.IntPtr hIcon);
52
53 // Initializes or reinitializes the system image list.
54 // FileIconInit is not included in a header file. You must call it directly from Shell32.dll, using ordinal 660.
55 [DllImport( "Shell32.dll", EntryPoint = "#660")]
56 private static extern bool FileIconInit( bool fRestoreCache );
57
58 // Retrieves the number of images in an image list.
59 [DllImport( "comctl32.dll")]
60 private static extern int ImageList_GetImageCount( IntPtr himl);
61
62 public Form1()
63 ...{
64 InitializeComponent();
65 }
66
67 private void Form1_Load(object sender, EventArgs e)
68 ...{
69 IntPtr hImgSmall; //handle to the small system image list
70 IntPtr hImgLarge; //handle to the large system image list
71 SHFILEINFO shinfo = new SHFILEINFO();
72
73 FileIconInit(true);
74
75 //Small Icons
76 hImgSmall = SHGetFileInfo("", 0, ref shinfo, (uint)Marshal.SizeOf(shinfo), SHGFI_SYSICONINDEX SHGFI_SMALLICON);
77
78 //Large Icons
79 hImgLarge = SHGetFileInfo("", 0, ref shinfo, (uint)Marshal.SizeOf(shinfo), SHGFI_SYSICONINDEX SHGFI_LARGEICON);
80
81 // Set Icon Images
82 SendMessage(listView1.Handle, LVM_SETIMAGELIST, LVSIL_SMALL, (uint)hImgSmall.ToInt32());
83 SendMessage(listView1.Handle, LVM_SETIMAGELIST, LVSIL_NORMAL, (uint)hImgLarge.ToInt32());
84
85 for ( int i = 0; i < ImageList_GetImageCount(hImgLarge) ; i++ )
86 ...{
87 listView1.Items.Add(i.ToString(),i);
88 }
89 }
90
91 private int Get_Image_Index(string filename)
92 ...{
93 IntPtr hImgSmall;
94 SHFILEINFO shinfo = new SHFILEINFO();
95
96 hImgSmall = SHGetFileInfo(filename, 0, ref shinfo, (uint)Marshal.SizeOf(shinfo.GetType()), SHGFI_ICON SHGFI_SMALLICON);
97 DestroyIcon(shinfo.hIcon);
98 return (int)shinfo.iIcon;
99 }
100 }

Labels: .NET, C#, Code