Another “put it in my blog so I don’t lose it” T-SQL nugget.
Nicer than just a raw text-based search, a where-used search for a named table.
select distinct [Found In] = sp.Name, sp.type_desc
from sys.objects o inner join sys.sql_expression_dependencies sd on o.object_id = sd.referenced_id
inner join sys.objects sp on sd.referencing_id = sp.object_id
where (o.name = 'Cow')
order by sp.Name
Inserts records into target that aren’t in source, deletes records that are no longer in source.
MERGE CowTarget AS t
USING CowSource AS s
ON (t.TargetCowId = s.CowId)
WHEN NOT MATCHED BY TARGET THEN
INSERT (TargetCowId, TargetName, TargetMotto)
VALUES (CowId, Name, Motto)
WHEN NOT MATCHED BY SOURCE THEN DELETE;
I prefer to use git from the command line, rather than using a GUI-based tool. Here are my favorite or most-used git commands.
Tools
Setting up Kdiff3 as diff/merge tool
Cloning – get local of repo
List branches (local and remote)
Create new local branch
Switch to new branch
Switch back to master (or another branch)
Push new branch (simple git push will suggest this)
Revert local changes (single file or all files)
Doing diffs of local changes
Sequence for commit/push changes
To unstage a file (reverse of git add)
To merge changes back to master, from branch
Update local, after merge
Switching to new branch that already exists on remote
Abandon a branch
Merging
If you have conflict
See also: Git Cheat Sheat by Tower
Using commands in WPF can be frustrating. Having so many different ways to do commanding in WPF leads to some confusion. There are multiple ways to wire up commands that are equally correct, though some patterns are cleaner than others.
Below is a pattern that works.
Create static property to expose command
Making the command a property rather than a variable makes the syntax in XAML a bit cleaner. Using RoutedUICommand allows setting the text for the command. This is useful if you want to use the command in multiple places.
Here’s code for creating the command, e.g. in a MainWindow class:
private static RoutedUICommand _pressMeCommand = new RoutedUICommand("Press Me", "PressMe", typeof(MainWindow));
public static RoutedUICommand PressMeCommand
{
get { return _pressMeCommand; }
}
Add CanExecute and Executed handlers
Add code in code-behind (or ViewModel) for handlers. Below, we have private handlers in MainWindow. In this example, we have a boolean indicating whether the command can be executed. You could also put the logic directly in CanExecute, if it’s not used elsewhere.
private void PressMe_CanExecute(object sender, CanExecuteRoutedEventArgs e)
{
e.CanExecute = CowboyCanTalk;
}
private void PressMe_Executed(object sender, ExecutedRoutedEventArgs e)
{
MessageBox.Show("Howdy howdy I'm a cowboy");
}
Set up command binding
You can do this from code or XAML. Doing it in XAML is perhaps a bit cleaner. Below is an example of binding the above command to its handlers from XAML (for MainWindow). Note that we can just use command name instead of {x:Static syntax because we made the command a property.
<Window.CommandBindings>
<CommandBinding Command="local:MainWindow.PressMeCommand"
CanExecute="PressMe_CanExecute"
Executed="PressMe_Executed"/>
</Window.CommandBindings>
Wire up a button
Below, we wire a button up to the command. You could just set Content to text directly. This would be fine to do and is simpler than what we’re doing below. But putting the text into the RoutedUICommand is helpful if you use the command in more than one place (since you specify text in just one place—in the command). And menu items automatically pick up the command text. (NOTE: If you used this pattern for Content regularly, you could just put it in a style to hide the complexity).
<Button Command="local:MainWindow.PressMeCommand"
Content="{Binding RelativeSource={RelativeSource Self}, Path=Command.Text}" />
Wire up a menu item
Below, we wire up a menu item in a context menu to the same command. Note that here we do have to use the x:Static syntax. But also note that we don’t need to specify text for the menu item—it comes from the RoutedUICommand.
<Window.ContextMenu>
<ContextMenu>
<MenuItem Command="{x:Static local:MainWindow.PressMeCommand}" />
</ContextMenu>
</Window.ContextMenu>
Bottom line
Other thoughts
Here are a few notes about best practices related to:
(NOTE: BackgroundWorker object is no longer the preferred mechanism for doing work on a background thread in C#, given that the language supports task-basked asynchrony with the async/await constructs. However, many legacy applications still make use of the BackgroundWorker class).
Q: What’s the goal of the using statement and IDisposable (Dispose) interface?
A: (short) To tell an object when it can clean up unmanaged resources that it might be hanging onto
A: (longer)
Q: When should I use the using statement?
A: Typically, you should use the using statement to invoke Dispose on any object that implements IDisposable
Q: What happens if I don’t call Dispose or use the using statement?
A: (short) Unmanaged resources are (typically) released a bit later than they otherwise would be
A: (longer)
Q: Should I use a using statement for a BackgroundWorker object?
A: (short) Yes, since BackgroundWorker has Dispose method (although calling Dispose doesn’t actually do anything)
A: (longer)
Q: Should I detach event handlers in the handler for RunWorkerCompleted?
A: (short) No, you (typically) don’t need to explicitly detach event handlers for a BackgroundWorker
A: (longer)
(NOTE: This is Model First development in Entity Framework–start with a data model in the Entity Framework Designer and then generate database schema from the model).
When you add a scalar property of type string to an entity data model, you can fill in the values of several other properties within Visual Studio.
What does a value of (None) mean for these properties (when generating SQL Server Database from model)?
Here’s how choices for these properties map to SQL Server data types:
This means that if you just pick String as the type and set nothing else, you’ll get nvarchar(max) as the SQL Server type.
NOTE: The value of 4,000 is being used because the maximum length of a fixed length string in SQL Server is 4,000 characters (8,000 bytes when encoded as UTF-16).
This is well covered in many other places, but I’m posting on my own blog so that I can more easily find this trick.
You can do paging in SQL Server 2012 and later using the OFFSET-FETCH syntax. This is useful for returning a single page’s worth of records from a larger (sorted) set of records. To count the total number of records, however, you’d normally do a second query. The T-SQL below shows how to do a total count as part of the query that returns the page in question. The count is repeated for every record, but it avoids having to do two queries.
select FirstName, LastName, COUNT(*) over () as TotalCount from Person where LastName like 'mc%' order by LastName, FirstName offset 500 rows fetch next 100 rows only
Here’s what the output looks like, returning records 501-600 out of 1,968 records having a last name that starts with “Mc”.
